/// <summary> /// Creates a <seealso cref="BatchTransactionApplierFacade"/> that is to be used for all transactions /// in a batch. Each transaction is handled by a <seealso cref="TransactionApplierFacade"/> which wraps the /// individual <seealso cref="TransactionApplier"/>s returned by the wrapped <seealso cref="BatchTransactionApplier"/>s. /// /// After all transactions have been applied the appliers are closed. /// </summary> protected internal virtual BatchTransactionApplierFacade Applier(TransactionApplicationMode mode, IndexActivator indexActivator) { List <BatchTransactionApplier> appliers = new List <BatchTransactionApplier>(); // Graph store application. The order of the decorated store appliers is irrelevant appliers.Add(new NeoStoreBatchTransactionApplier(mode.version(), _neoStores, _cacheAccess, LockService(mode))); if (mode.needsHighIdTracking()) { appliers.Add(new HighIdBatchTransactionApplier(_neoStores)); } if (mode.needsCacheInvalidationOnUpdates()) { appliers.Add(new CacheInvalidationBatchTransactionApplier(_neoStores, _cacheAccess)); } if (mode.needsAuxiliaryStores()) { // Counts store application appliers.Add(new CountsStoreBatchTransactionApplier(_neoStores.Counts, mode)); // Schema index application appliers.Add(new IndexBatchTransactionApplier(_indexingService, _labelScanStoreSync, _indexUpdatesSync, _neoStores.NodeStore, _neoStores.RelationshipStore, _neoStores.PropertyStore, indexActivator)); // Explicit index application appliers.Add(new ExplicitBatchIndexApplier(_indexConfigStore, _explicitIndexApplierLookup, _explicitIndexTransactionOrdering, mode)); } // Perform the application return(new BatchTransactionApplierFacade(appliers.ToArray())); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public long commit(final org.neo4j.kernel.impl.api.TransactionToApply tx, final org.neo4j.kernel.impl.transaction.tracing.CommitEvent commitEvent, org.neo4j.storageengine.api.TransactionApplicationMode mode) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException //JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: public override long Commit(TransactionToApply tx, CommitEvent commitEvent, TransactionApplicationMode mode) { TransactionRepresentationReplicatedTransaction transaction = ReplicatedTransaction.from(tx.TransactionRepresentation()); Future <object> futureTxId; try { futureTxId = _replicator.replicate(transaction, true); } catch (ReplicationFailureException e) { throw new TransactionFailureException(ReplicationFailure, e); } try { return(( long )futureTxId.get()); } catch (ExecutionException e) { if (e.InnerException is TransactionFailureException) { throw ( TransactionFailureException )e.InnerException; } // TODO: Panic? throw new Exception(e); } catch (InterruptedException e) { // TODO Wait for the transaction to possibly finish within a user configurable time, before aborting. throw new TransactionFailureException("Interrupted while waiting for txId", e); } }
public ExplicitIndexTransactionApplier(ExplicitIndexApplierLookup applierLookup, IndexConfigStore indexConfigStore, TransactionApplicationMode mode, IdOrderingQueue transactionOrdering) { this._applierLookup = applierLookup; this._indexConfigStore = indexConfigStore; this._mode = mode; this._transactionOrdering = transactionOrdering; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void apply(org.neo4j.storageengine.api.CommandsToApply batch, org.neo4j.storageengine.api.TransactionApplicationMode mode) throws Exception public override void Apply(CommandsToApply batch, TransactionApplicationMode mode) { // Have these command appliers as separate try-with-resource to have better control over // point between closing this and the locks above try { using (IndexActivator indexActivator = new IndexActivator(_indexingService), LockGroup locks = new LockGroup(), BatchTransactionApplier batchApplier = Applier(mode, indexActivator)) { while (batch != null) { using (TransactionApplier txApplier = batchApplier.StartTx(batch, locks)) { batch.Accept(txApplier); } batch = batch.Next(); } } } catch (Exception cause) { TransactionApplyKernelException kernelException = new TransactionApplyKernelException(cause, "Failed to apply transaction: %s", batch); _databaseHealth.panic(kernelException); throw kernelException; } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public org.neo4j.kernel.recovery.RecoveryApplier getRecoveryApplier(org.neo4j.storageengine.api.TransactionApplicationMode mode) throws Exception public override RecoveryApplier getRecoveryApplier(TransactionApplicationMode mode) { RecoveryApplier actual = base.getRecoveryApplier(mode); if (mode == TransactionApplicationMode.REVERSE_RECOVERY) { return(actual); } return(new RecoveryApplierAnonymousInnerClass(this, actual)); }
public CountsStoreBatchTransactionApplier(CountsTracker countsTracker, TransactionApplicationMode mode) { this._countsTracker = countsTracker; this._mode = mode; }
public override long Commit(TransactionToApply batch, CommitEvent commitEvent, TransactionApplicationMode mode) { Debug.Assert(Transaction == null, "Designed to only allow one transaction"); Debug.Assert(batch.Next() == null, "Designed to only allow one transaction"); Transaction = batch.TransactionRepresentation(); return(++TxId); }
public override long Commit(TransactionToApply batch, CommitEvent commitEvent, TransactionApplicationMode mode) { int batchSize = Count(batch); BatchSizes.AddLast(batchSize); return(42); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: protected void applyToStore(TransactionToApply batch, org.neo4j.kernel.impl.transaction.tracing.CommitEvent commitEvent, org.neo4j.storageengine.api.TransactionApplicationMode mode) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException protected internal virtual void ApplyToStore(TransactionToApply batch, CommitEvent commitEvent, TransactionApplicationMode mode) { try { using (StoreApplyEvent storeApplyEvent = commitEvent.BeginStoreApply()) { _storageEngine.apply(batch, mode); } } catch (Exception cause) { throw new TransactionFailureException(TransactionCommitFailed, cause, "Could not apply the transaction to the store after written to log"); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public long commit(TransactionToApply batch, org.neo4j.kernel.impl.transaction.tracing.CommitEvent commitEvent, org.neo4j.storageengine.api.TransactionApplicationMode mode) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException public override long Commit(TransactionToApply batch, CommitEvent commitEvent, TransactionApplicationMode mode) { long lastTxId = AppendToLog(batch, commitEvent); try { ApplyToStore(batch, commitEvent, mode); return(lastTxId); } finally { Close(batch); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public long commit(org.neo4j.kernel.impl.api.TransactionToApply batch, org.neo4j.kernel.impl.transaction.tracing.CommitEvent commitEvent, org.neo4j.storageengine.api.TransactionApplicationMode mode) throws org.neo4j.graphdb.TransactionFailureException public override long Commit(TransactionToApply batch, CommitEvent commitEvent, TransactionApplicationMode mode) { TransactionsToApply.Add(batch.TransactionRepresentation()); return(-1); }
public RecoveryApplier getRecoveryApplier(TransactionApplicationMode mode) { return(mode == TransactionApplicationMode.REVERSE_RECOVERY ? mock(typeof(RecoveryApplier)) : _visitor); }
private LockService LockService(TransactionApplicationMode mode) { return(mode == RECOVERY || mode == REVERSE_RECOVERY ? NO_LOCK_SERVICE : _lockService); }
public CountsStoreTransactionApplier(TransactionApplicationMode mode, CountsAccessor_Updater countsUpdater) { this._mode = mode; this._countsUpdater = countsUpdater; }