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

Example 66 with StorageCommand

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

the class LogCommandSerializationV4_0Test method readRelationshipGroupCommandWithNonRequiredSecondaryUnit.

@Test
void readRelationshipGroupCommandWithNonRequiredSecondaryUnit() throws IOException {
    // Given
    InMemoryClosableChannel channel = new InMemoryClosableChannel();
    RelationshipGroupRecord before = new RelationshipGroupRecord(42).initialize(false, 3, NULL_REF, NULL_REF, NULL_REF, NULL_REF, NULL_REF);
    RelationshipGroupRecord after = new RelationshipGroupRecord(42).initialize(true, 3, 4, 5, 6, 7, 8);
    after.setSecondaryUnitIdOnCreate(17);
    after.setCreated();
    new Command.RelationshipGroupCommand(writer(), before, after).serialize(channel);
    // When
    CommandReader reader = createReader();
    StorageCommand command = reader.read(channel);
    assertTrue(command instanceof Command.RelationshipGroupCommand);
    Command.RelationshipGroupCommand relationshipGroupCommand = (Command.RelationshipGroupCommand) command;
    // Then
    assertBeforeAndAfterEquals(relationshipGroupCommand, before, after);
}

Example 67 with StorageCommand

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

the class BatchingNeoStoresTest method apply.

private static void apply(TxState txState, CommandCreationContext commandCreationContext, RecordStorageEngine storageEngine) throws Exception {
    List<StorageCommand> commands = new ArrayList<>();
    try (RecordStorageReader storageReader = storageEngine.newReader()) {
        storageEngine.createCommands(commands, txState, storageReader, commandCreationContext, ResourceLocker.IGNORE, LockTracer.NONE, BASE_TX_ID, v -> v, NULL, INSTANCE);
        CommandsToApply apply = new TransactionToApply(new PhysicalTransactionRepresentation(commands, new byte[0], 0, 0, 0, 0, ANONYMOUS), NULL);
        storageEngine.apply(apply, TransactionApplicationMode.INTERNAL);
    }
}

Example 68 with StorageCommand

use of org.neo4j.storageengine.api.StorageCommand 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 69 with StorageCommand

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

the class PhysicalTransactionRepresentation method toString.

public String toString(boolean includeCommands) {
    String basic = format("%s[timeStarted:%d, latestCommittedTxWhenStarted:%d, timeCommitted:%d, lease:%d, additionalHeader:%s, commands.length:%d", getClass().getSimpleName(), timeStarted, latestCommittedTxWhenStarted, timeCommitted, leaseId, Arrays.toString(additionalHeader), commands.size());
    if (!includeCommands) {
        return basic;
    }
    StringBuilder builder = new StringBuilder(basic);
    for (StorageCommand command : commands) {
        builder.append(format("%n%s", command.toString()));
    }
    return builder.toString();
}

Example 70 with StorageCommand

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

the class TransactionLogAppendAndRotateIT method sillyTransaction.

private static TransactionRepresentation sillyTransaction(int size) {
    List<StorageCommand> commands = new ArrayList<>(size);
    for (int i = 0; i < size; i++) {
        // The actual data isn't super important
        commands.add(new TestCommand(30));
        commands.add(new TestCommand(60));
    }
    PhysicalTransactionRepresentation tx = new PhysicalTransactionRepresentation(commands);
    tx.setHeader(new byte[0], 0, 0, 0, 0, ANONYMOUS);
    return tx;
}