Examples with KeyReadTokenNameLookup org.neo4j.kernel.api.KeyReadTokenNameLookup used on opensource projects

Example 1 with KeyReadTokenNameLookup

use of org.neo4j.kernel.api.KeyReadTokenNameLookup in project neo4j by neo4j.

the class KernelTransactionImplementation method commit.

private long commit() throws TransactionFailureException {
    boolean success = false;
    long txId = READ_ONLY;
    try (CommitEvent commitEvent = transactionEvent.beginCommitEvent()) {
        // Trigger transaction "before" hooks.
        if (hasDataChanges()) {
            try {
                hooksState = hooks.beforeCommit(txState, this, storageEngine.storeReadLayer(), storageStatement);
                if (hooksState != null && hooksState.failed()) {
                    TransactionHookException cause = hooksState.failure();
                    throw new TransactionFailureException(Status.Transaction.TransactionHookFailed, cause, "");
                }
            } finally {
                beforeHookInvoked = true;
            }
        }
        // Convert changes into commands and commit
        if (hasChanges()) {
            // grab all optimistic locks now, locks can't be deferred any further
            statementLocks.prepareForCommit();
            // use pessimistic locks for the rest of the commit process, locks can't be deferred any further
            Locks.Client commitLocks = statementLocks.pessimistic();
            // Gather up commands from the various sources
            Collection<StorageCommand> extractedCommands = new ArrayList<>();
            storageEngine.createCommands(extractedCommands, txState, storageStatement, commitLocks, lastTransactionIdWhenStarted);
            if (hasLegacyIndexChanges()) {
                legacyIndexTransactionState.extractCommands(extractedCommands);
            }
            /* Here's the deal: we track a quick-to-access hasChanges in transaction state which is true
                 * if there are any changes imposed by this transaction. Some changes made inside a transaction undo
                 * previously made changes in that same transaction, and so at some point a transaction may have
                 * changes and at another point, after more changes seemingly,
                 * the transaction may not have any changes.
                 * However, to track that "undoing" of the changes is a bit tedious, intrusive and hard to maintain
                 * and get right.... So to really make sure the transaction has changes we re-check by looking if we
                 * have produced any commands to add to the logical log.
                 */
            if (!extractedCommands.isEmpty()) {
                // Finish up the whole transaction representation
                PhysicalTransactionRepresentation transactionRepresentation = new PhysicalTransactionRepresentation(extractedCommands);
                TransactionHeaderInformation headerInformation = headerInformationFactory.create();
                long timeCommitted = clock.millis();
                transactionRepresentation.setHeader(headerInformation.getAdditionalHeader(), headerInformation.getMasterId(), headerInformation.getAuthorId(), startTimeMillis, lastTransactionIdWhenStarted, timeCommitted, commitLocks.getLockSessionId());
                // Commit the transaction
                success = true;
                TransactionToApply batch = new TransactionToApply(transactionRepresentation);
                txId = transactionId = commitProcess.commit(batch, commitEvent, INTERNAL);
                commitTime = timeCommitted;
            }
        }
        success = true;
        return txId;
    } catch (ConstraintValidationException | CreateConstraintFailureException e) {
        throw new ConstraintViolationTransactionFailureException(e.getUserMessage(new KeyReadTokenNameLookup(currentTransactionOperations.keyReadOperations())), e);
    } finally {
        if (!success) {
            rollback();
        } else {
            afterCommit(txId);
        }
    }
}