diff --git a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundQueryContextTest.scala b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundQueryContextTest.scala
index 511af6fe7c37..ccdceac80725 100644
--- a/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundQueryContextTest.scala
+++ b/community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundQueryContextTest.scala
@@ -59,8 +59,7 @@ class TransactionBoundQueryContextTest extends CypherFunSuite {
     val kernelTransaction = mock[KernelTransactionImplementation]
     when(kernelTransaction.mode()).thenReturn(AccessMode.Static.FULL)
     val storeStatement = mock[StorageStatement]
-    val operations = mock[StatementOperationParts](RETURNS_DEEP_STUBS)
-    statement = new KernelStatement(kernelTransaction, null, operations, storeStatement, new Procedures())
+    statement = new KernelStatement(kernelTransaction, null, storeStatement, new Procedures())
     statement.acquire()
   }
 
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java
index fcfd8df57a55..467613a9f68f 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java
@@ -63,6 +63,7 @@
 import org.neo4j.kernel.impl.api.SchemaWriteGuard;
 import org.neo4j.kernel.impl.api.StackingQueryRegistrationOperations;
 import org.neo4j.kernel.impl.api.StateHandlingStatementOperations;
+import org.neo4j.kernel.impl.api.StatementOperationContainer;
 import org.neo4j.kernel.impl.api.StatementOperationParts;
 import org.neo4j.kernel.impl.api.TransactionCommitProcess;
 import org.neo4j.kernel.impl.api.TransactionHooks;
@@ -163,7 +164,6 @@
 import org.neo4j.logging.Logger;
 import org.neo4j.storageengine.api.StorageEngine;
 import org.neo4j.storageengine.api.StoreReadLayer;
-import org.neo4j.time.Clocks;
 
 import static org.neo4j.kernel.impl.transaction.log.pruning.LogPruneStrategyFactory.fromConfigValue;
 
@@ -788,13 +788,13 @@ private KernelModule buildKernel( TransactionAppender appender,
         LegacyIndexStore legacyIndexStore = new LegacyIndexStore( config,
                 indexConfigStore, kernelProvider, legacyIndexProviderLookup );
 
-        StatementOperationParts statementOperations = dependencies.satisfyDependency( buildStatementOperations(
-                storeLayer, autoIndexing, constraintIndexCreator, updateableSchemaState, guard,
-                legacyIndexStore ) );
+        StatementOperationContainer statementOperationContainer = dependencies.satisfyDependency(
+                buildStatementOperations( storeLayer, autoIndexing,
+                        constraintIndexCreator, updateableSchemaState, guard, legacyIndexStore ) );
 
         TransactionHooks hooks = new TransactionHooks();
         KernelTransactions kernelTransactions = life.add( new KernelTransactions( statementLocksFactory,
-                constraintIndexCreator, statementOperations, schemaWriteGuard, transactionHeaderInformationFactory,
+                constraintIndexCreator, statementOperationContainer, schemaWriteGuard, transactionHeaderInformationFactory,
                 transactionCommitProcess, indexConfigStore, legacyIndexProviderLookup, hooks, transactionMonitor, life,
                 tracers, storageEngine, procedures, transactionIdStore, clock ) );
 
@@ -972,7 +972,7 @@ public DependencyResolver getDependencyResolver()
         return dependencies;
     }
 
-    private StatementOperationParts buildStatementOperations(
+    private StatementOperationContainer buildStatementOperations(
             StoreReadLayer storeReadLayer, AutoIndexing autoIndexing,
             ConstraintIndexCreator constraintIndexCreator, UpdateableSchemaState updateableSchemaState,
             Guard guard, LegacyIndexStore legacyIndexStore )
@@ -985,7 +985,7 @@ private StatementOperationParts buildStatementOperations(
                 legacyIndexStore );
 
         QueryRegistrationOperations queryRegistrationOperations =
-                new StackingQueryRegistrationOperations( StackingQueryRegistrationOperations.LAST_QUERY_ID, Clocks.systemClock() );
+                new StackingQueryRegistrationOperations( StackingQueryRegistrationOperations.LAST_QUERY_ID, clock );
 
         StatementOperationParts parts = new StatementOperationParts( stateHandlingContext, stateHandlingContext,
                 stateHandlingContext, stateHandlingContext, stateHandlingContext, stateHandlingContext,
@@ -1010,10 +1010,11 @@ private StatementOperationParts buildStatementOperations(
         // + Guard
         GuardingStatementOperations guardingOperations = new GuardingStatementOperations(
                 parts.entityWriteOperations(), parts.entityReadOperations(), guard );
-        parts = parts.override( null, null, guardingOperations, guardingOperations, null, null, null, null,
+        StatementOperationParts guardedParts = parts.override( null, null, guardingOperations,
+                guardingOperations, null, null, null, null,
                 null, null, null, null );
 
-        return parts;
+        return new StatementOperationContainer( guardedParts, parts );
     }
 
     @Override
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java
index 808b3e265a88..e6bbd377ca6d 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelStatement.java
@@ -45,14 +45,14 @@
  * <ol>
  * <li>Construct {@link KernelStatement} when {@link KernelTransactionImplementation} is constructed</li>
  * <li>For every transaction...</li>
- * <li>Call {@link #initialize(StatementLocks)} which makes this instance
+ * <li>Call {@link #initialize(StatementLocks, StatementOperationParts)} which makes this instance
  * full available and ready to use. Call when the {@link KernelTransactionImplementation} is initialized.</li>
  * <li>Alternate {@link #acquire()} / {@link #close()} when acquiring / closing a statement for the transaction...
  * Temporarily asymmetric number of calls to {@link #acquire()} / {@link #close()} is supported, although in
  * the end an equal number of calls must have been issued.</li>
  * <li>To be safe call {@link #forceClose()} at the end of a transaction to force a close of the statement,
  * even if there are more than one current call to {@link #acquire()}. This instance is now again ready
- * to be {@link #initialize(StatementLocks)  initialized} and used for the transaction
+ * to be {@link #initialize(StatementLocks, StatementOperationParts)  initialized} and used for the transaction
  * instance again, when it's initialized.</li>
  * </ol>
  */
@@ -66,18 +66,13 @@ public class KernelStatement implements TxStateHolder, Statement
     private int referenceCount;
     private volatile ExecutingQueryList executingQueryList;
 
-    public KernelStatement(
-        KernelTransactionImplementation transaction,
-        TxStateHolder txStateHolder,
-        StatementOperationParts operations,
-        StorageStatement storeStatement,
-        Procedures procedures
-    )
+    public KernelStatement( KernelTransactionImplementation transaction,
+            TxStateHolder txStateHolder, StorageStatement storeStatement, Procedures procedures )
     {
         this.transaction = transaction;
         this.txStateHolder = txStateHolder;
         this.storeStatement = storeStatement;
-        this.facade = new OperationsFacade( transaction, this, operations, procedures );
+        this.facade = new OperationsFacade( transaction, this, procedures );
         this.executingQueryList = ExecutingQueryList.EMPTY;
     }
 
@@ -173,9 +168,10 @@ void assertOpen()
         }
     }
 
-    void initialize( StatementLocks statementLocks )
+    void initialize( StatementLocks statementLocks, StatementOperationParts operationParts )
     {
         this.statementLocks = statementLocks;
+        facade.initialize( operationParts );
     }
 
     public StatementLocks locks()
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java
index 55c03ae08202..b755fc8b3c01 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java
@@ -127,7 +127,7 @@ TransactionWriteState upgradeToSchemaWrites() throws InvalidTransactionTypeKerne
     private final SchemaWriteGuard schemaWriteGuard;
     private final TransactionHooks hooks;
     private final ConstraintIndexCreator constraintIndexCreator;
-    private final StatementOperationParts operations;
+    private final StatementOperationContainer operationContainer;
     private final StorageEngine storageEngine;
     private final TransactionTracer tracer;
     private final Pool<KernelTransactionImplementation> pool;
@@ -146,6 +146,7 @@ TransactionWriteState upgradeToSchemaWrites() throws InvalidTransactionTypeKerne
     private LegacyIndexTransactionState legacyIndexTransactionState;
     private TransactionWriteState writeState;
     private TransactionHooks.TransactionHooksState hooksState;
+    private StatementOperationParts currentTransactionOperations;
     private final KernelStatement currentStatement;
     private final StorageStatement storageStatement;
     private final List<CloseListener> closeListeners = new ArrayList<>( 2 );
@@ -174,7 +175,7 @@ TransactionWriteState upgradeToSchemaWrites() throws InvalidTransactionTypeKerne
      */
     private final Lock terminationReleaseLock = new ReentrantLock();
 
-    public KernelTransactionImplementation( StatementOperationParts operations,
+    public KernelTransactionImplementation( StatementOperationContainer operationContainer,
                                             SchemaWriteGuard schemaWriteGuard,
                                             TransactionHooks hooks,
                                             ConstraintIndexCreator constraintIndexCreator,
@@ -188,7 +189,7 @@ public KernelTransactionImplementation( StatementOperationParts operations,
                                             TransactionTracer tracer,
                                             StorageEngine storageEngine )
     {
-        this.operations = operations;
+        this.operationContainer = operationContainer;
         this.schemaWriteGuard = schemaWriteGuard;
         this.hooks = hooks;
         this.constraintIndexCreator = constraintIndexCreator;
@@ -202,7 +203,7 @@ public KernelTransactionImplementation( StatementOperationParts operations,
         this.clock = clock;
         this.tracer = tracer;
         this.storageStatement = storeLayer.newStatement();
-        this.currentStatement = new KernelStatement( this, this, operations, storageStatement, procedures );
+        this.currentStatement = new KernelStatement( this, this, storageStatement, procedures );
     }
 
     /**
@@ -226,7 +227,8 @@ public KernelTransactionImplementation initialize(
         this.accessMode = accessMode;
         this.transactionId = NOT_COMMITTED_TRANSACTION_ID;
         this.commitTime = NOT_COMMITTED_TRANSACTION_COMMIT_TIME;
-        this.currentStatement.initialize( statementLocks );
+        this.currentTransactionOperations = timeoutMillis > 0 ? operationContainer.guardedParts() : operationContainer.nonGuarderParts();
+        this.currentStatement.initialize( statementLocks, currentTransactionOperations );
         return this;
     }
 
@@ -605,7 +607,7 @@ private long commit() throws TransactionFailureException
         catch ( ConstraintValidationKernelException | CreateConstraintFailureException e )
         {
             throw new ConstraintViolationTransactionFailureException(
-                    e.getUserMessage( new KeyReadTokenNameLookup( operations.keyReadOperations() ) ), e );
+                    e.getUserMessage( new KeyReadTokenNameLookup( currentTransactionOperations.keyReadOperations() ) ), e );
         }
         finally
         {
@@ -718,6 +720,7 @@ private void release()
             legacyIndexTransactionState = null;
             txState = null;
             hooksState = null;
+            currentTransactionOperations = null;
             closeListeners.clear();
             reuseCount++;
             pool.release( this );
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java
index 9321aae31dc6..3a98d9bd509a 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java
@@ -68,7 +68,7 @@ public class KernelTransactions extends LifecycleAdapter
 
     private final StatementLocksFactory statementLocksFactory;
     private final ConstraintIndexCreator constraintIndexCreator;
-    private final StatementOperationParts statementOperations;
+    private final StatementOperationContainer statementOperations;
     private final SchemaWriteGuard schemaWriteGuard;
     private final TransactionHeaderInformationFactory transactionHeaderInformationFactory;
     private final TransactionCommitProcess transactionCommitProcess;
@@ -100,7 +100,7 @@ public class KernelTransactions extends LifecycleAdapter
 
     public KernelTransactions( StatementLocksFactory statementLocksFactory,
                                ConstraintIndexCreator constraintIndexCreator,
-                               StatementOperationParts statementOperations,
+                               StatementOperationContainer statementOperationContainer,
                                SchemaWriteGuard schemaWriteGuard,
                                TransactionHeaderInformationFactory txHeaderFactory,
                                TransactionCommitProcess transactionCommitProcess,
@@ -117,7 +117,7 @@ public KernelTransactions( StatementLocksFactory statementLocksFactory,
     {
         this.statementLocksFactory = statementLocksFactory;
         this.constraintIndexCreator = constraintIndexCreator;
-        this.statementOperations = statementOperations;
+        this.statementOperations = statementOperationContainer;
         this.schemaWriteGuard = schemaWriteGuard;
         this.transactionHeaderInformationFactory = txHeaderFactory;
         this.transactionCommitProcess = transactionCommitProcess;
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java
index d9fe54afdbdf..b6152a86c88a 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/OperationsFacade.java
@@ -101,18 +101,22 @@ public class OperationsFacade
 {
     private final KernelTransaction tx;
     private final KernelStatement statement;
-    private final StatementOperationParts operations;
     private final Procedures procedures;
+    private StatementOperationParts operations;
 
     OperationsFacade( KernelTransaction tx, KernelStatement statement,
-                      StatementOperationParts operations, Procedures procedures )
+                      Procedures procedures )
     {
         this.tx = tx;
         this.statement = statement;
-        this.operations = operations;
         this.procedures = procedures;
     }
 
+    public void initialize( StatementOperationParts operationParts )
+    {
+        this.operations = operationParts;
+    }
+
     final KeyReadOperations tokenRead()
     {
         return operations.keyReadOperations();
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StatementOperationContainer.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StatementOperationContainer.java
new file mode 100644
index 000000000000..b064f74d7302
--- /dev/null
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/api/StatementOperationContainer.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2002-2016 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.impl.api;
+
+/**
+ * Container for different version of operation parts.
+ * To allow dynamic parts switching depending of transaction nature.
+ * <ul>
+ * Currently supported only 2 different kinds of parts:
+ * <li>full chain of operation without guarding layer</li>
+ * <li>full chain of operation with guarding layer</li>
+ * </ul>
+ */
+public class StatementOperationContainer
+{
+    private StatementOperationParts guardedParts;
+    private StatementOperationParts nonGuarderParts;
+
+    public StatementOperationContainer( StatementOperationParts guardedParts,
+            StatementOperationParts nonGuarderParts )
+    {
+        this.guardedParts = guardedParts;
+        this.nonGuarderParts = nonGuarderParts;
+    }
+
+    public StatementOperationParts guardedParts()
+    {
+        return guardedParts;
+    }
+
+    public StatementOperationParts nonGuarderParts()
+    {
+        return nonGuarderParts;
+    }
+}
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionFactory.java b/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionFactory.java
index 27de8cf8affe..48fbde687226 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionFactory.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionFactory.java
@@ -19,14 +19,13 @@
  */
 package org.neo4j.kernel.api;
 
-import java.time.Clock;
 import java.util.function.Supplier;
 
 import org.neo4j.collection.pool.Pool;
 import org.neo4j.kernel.api.security.AccessMode;
 import org.neo4j.kernel.impl.api.KernelTransactionImplementation;
 import org.neo4j.kernel.impl.api.SchemaWriteGuard;
-import org.neo4j.kernel.impl.api.StatementOperationParts;
+import org.neo4j.kernel.impl.api.StatementOperationContainer;
 import org.neo4j.kernel.impl.api.TransactionHeaderInformation;
 import org.neo4j.kernel.impl.api.TransactionHooks;
 import org.neo4j.kernel.impl.api.TransactionRepresentationCommitProcess;
@@ -78,7 +77,7 @@ static Instances kernelTransactionWithInternals( AccessMode accessMode )
         when( storageEngine.storeReadLayer() ).thenReturn( storeReadLayer );
 
         KernelTransactionImplementation transaction = new KernelTransactionImplementation(
-                mock( StatementOperationParts.class ),
+                mock( StatementOperationContainer.class ),
                 mock( SchemaWriteGuard.class ),
                 new TransactionHooks(),
                 mock( ConstraintIndexCreator.class ), new Procedures(), headerInformationFactory,
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/DataStatementArgumentVerificationTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/DataStatementArgumentVerificationTest.java
index 93939de34c37..f5b73af77812 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/DataStatementArgumentVerificationTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/DataStatementArgumentVerificationTest.java
@@ -103,6 +103,6 @@ public void shouldAlwaysReturnFalseFromNodeHasLabelForNoSuchLabelConstant() thro
 
     private OperationsFacade stubStatement()
     {
-        return new OperationsFacade( mock(KernelTransaction.class), mock( KernelStatement.class ), null, new Procedures() );
+        return new OperationsFacade( mock(KernelTransaction.class), mock( KernelStatement.class ), new Procedures() );
     }
 }
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelStatementTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelStatementTest.java
index 996912fefdc4..885ed437dd71 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelStatementTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelStatementTest.java
@@ -40,7 +40,7 @@ public void shouldThrowTerminateExceptionWhenTransactionTerminated() throws Exce
         when( transaction.getReasonIfTerminated() ).thenReturn( Status.Transaction.Terminated );
         when( transaction.mode() ).thenReturn( AccessMode.Static.FULL );
 
-        KernelStatement statement = new KernelStatement( transaction, null, null, mock( StorageStatement.class ), null );
+        KernelStatement statement = new KernelStatement( transaction, null, mock( StorageStatement.class ), null );
         statement.acquire();
 
         statement.readOperations().nodeExists( 0 );
@@ -52,7 +52,7 @@ public void shouldReleaseStorageStatementWhenForceClosed() throws Exception
         // given
         StorageStatement storeStatement = mock( StorageStatement.class );
         KernelStatement statement = new KernelStatement( mock( KernelTransactionImplementation.class ),
-                null, null, storeStatement, new Procedures() );
+                null, storeStatement, new Procedures() );
         statement.acquire();
 
         // when
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java
index 2ff75491c51d..d5d9475efd1f 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java
@@ -101,6 +101,26 @@ public static Collection<Object[]> parameters()
         );
     }
 
+    @Test
+    public void useGuardedPartsWhenTransactionHaveTimeout() throws Exception
+    {
+        try ( KernelTransaction transaction = newTransaction( 10L ) )
+        {
+            transaction.success();
+        }
+        verify( operationContainer ).guardedParts();
+    }
+
+    @Test
+    public void useNonGuardedPartsWhenTransactionHaveTimeout() throws Exception
+    {
+        try ( KernelTransaction transaction = newTransaction( accessMode() ) )
+        {
+            transaction.success();
+        }
+        verify( operationContainer ).nonGuarderParts();
+    }
+
     @Test
     public void shouldCommitSuccessfulTransaction() throws Exception
     {
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTerminationTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTerminationTest.java
index b9fef6ef09bf..53612419eb09 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTerminationTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTerminationTest.java
@@ -357,7 +357,7 @@ private static class TestKernelTransaction extends KernelTransactionImplementati
         @SuppressWarnings( "unchecked" )
         TestKernelTransaction( CommitTrackingMonitor monitor )
         {
-            super( mock( StatementOperationParts.class ), mock( SchemaWriteGuard.class ), new TransactionHooks(),
+            super( mock( StatementOperationContainer.class ), mock( SchemaWriteGuard.class ), new TransactionHooks(),
                     mock( ConstraintIndexCreator.class ), new Procedures(), TransactionHeaderInformationFactory.DEFAULT,
                     mock( TransactionCommitProcess.class ), monitor, () -> mock( LegacyIndexTransactionState.class ),
                     mock( Pool.class ), Clocks.fakeClock(), TransactionTracer.NULL,
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java
index 396db9e28cb4..539a86815492 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java
@@ -78,6 +78,8 @@ public class KernelTransactionTestBase
     protected final SchemaWriteGuard schemaWriteGuard = mock( SchemaWriteGuard.class );
     protected final FakeClock clock = Clocks.fakeClock();
     protected final Pool<KernelTransactionImplementation> txPool = mock( Pool.class );
+    protected final StatementOperationContainer operationContainer = mock( StatementOperationContainer.class );
+
     private final long defaultTransactionTimeoutMillis = GraphDatabaseSettings.transaction_timeout.from( Config.defaults() );
 
     @Before
@@ -132,9 +134,9 @@ public KernelTransactionImplementation newTransaction( long lastTransactionIdWhe
 
     public KernelTransactionImplementation newNotInitializedTransaction()
     {
-        return new KernelTransactionImplementation( null, schemaWriteGuard, hooks, null, null, headerInformationFactory,
-                commitProcess, transactionMonitor, legacyIndexStateSupplier, txPool, clock, TransactionTracer.NULL,
-                storageEngine );
+        return new KernelTransactionImplementation( operationContainer, schemaWriteGuard,
+                hooks, null, null, headerInformationFactory, commitProcess, transactionMonitor, legacyIndexStateSupplier,
+                txPool, clock, TransactionTracer.NULL, storageEngine );
     }
 
     public class CapturingCommitProcess implements TransactionCommitProcess
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java
index 23030c43a089..42ac11fe1ba1 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionsTest.java
@@ -440,15 +440,16 @@ private static KernelTransactions newKernelTransactions( Locks locks, StorageEng
         Tracers tracers = new Tracers( "null", NullLog.getInstance(), new Monitors(), mock( JobScheduler.class ) );
         StatementLocksFactory statementLocksFactory = new SimpleStatementLocksFactory( locks );
 
+        StatementOperationContainer statementOperationsContianer = new StatementOperationContainer( null, null );
         if ( testKernelTransactions )
         {
-            return new TestKernelTransactions( statementLocksFactory, null, null, null,
-                    DEFAULT,
+            return new TestKernelTransactions( statementLocksFactory, null, statementOperationsContianer,
+                    null, DEFAULT,
                     commitProcess, null, null, new TransactionHooks(), mock( TransactionMonitor.class ), life,
                     tracers, storageEngine, new Procedures(), transactionIdStore, Clocks.systemClock() );
         }
         return new KernelTransactions( statementLocksFactory,
-                null, null, null, DEFAULT,
+                null, statementOperationsContianer, null, DEFAULT,
                 commitProcess, null, null, new TransactionHooks(), mock( TransactionMonitor.class ), life,
                 tracers, storageEngine, new Procedures(), transactionIdStore, Clocks.systemClock() );
     }
@@ -520,7 +521,7 @@ private static class TestKernelTransactions extends KernelTransactions
     {
         public TestKernelTransactions( StatementLocksFactory statementLocksFactory,
                 ConstraintIndexCreator constraintIndexCreator,
-                StatementOperationParts statementOperations, SchemaWriteGuard schemaWriteGuard,
+                StatementOperationContainer statementOperationsContianer, SchemaWriteGuard schemaWriteGuard,
                 TransactionHeaderInformationFactory txHeaderFactory,
                 TransactionCommitProcess transactionCommitProcess,
                 IndexConfigStore indexConfigStore,
@@ -529,7 +530,7 @@ public TestKernelTransactions( StatementLocksFactory statementLocksFactory,
                 Tracers tracers, StorageEngine storageEngine, Procedures procedures,
                 TransactionIdStore transactionIdStore, Clock clock )
         {
-            super( statementLocksFactory, constraintIndexCreator, statementOperations, schemaWriteGuard, txHeaderFactory,
+            super( statementLocksFactory, constraintIndexCreator, statementOperationsContianer, schemaWriteGuard, txHeaderFactory,
                     transactionCommitProcess, indexConfigStore, legacyIndexProviderLookup, hooks, transactionMonitor,
                     dataSourceLife, tracers, storageEngine, procedures, transactionIdStore, clock );
         }
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/LockingStatementOperationsTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/LockingStatementOperationsTest.java
index 60d459b0f57c..6120fd495da6 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/LockingStatementOperationsTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/LockingStatementOperationsTest.java
@@ -73,7 +73,7 @@ public class LockingStatementOperationsTest
     private final KernelTransactionImplementation transaction = mock( KernelTransactionImplementation.class );
     private final TxState txState = new TxState();
     private final KernelStatement state = new KernelStatement( transaction, new SimpleTxStateHolder( txState ),
-            null, mock( StorageStatement.class ), new Procedures() );
+            mock( StorageStatement.class ), new Procedures() );
     private final SchemaStateOperations schemaStateOps;
 
     public LockingStatementOperationsTest()
@@ -87,7 +87,7 @@ public LockingStatementOperationsTest()
         lockingOps = new LockingStatementOperations(
                 entityReadOps, entityWriteOps, schemaReadOps, schemaWriteOps, schemaStateOps
         );
-        state.initialize( new SimpleStatementLocks( locks ) );
+        state.initialize( new SimpleStatementLocks( locks ), null );
         state.acquire();
     }
 
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/OperationsFacadeTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/OperationsFacadeTest.java
index 9a4e08fdbd9e..38b7204da515 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/OperationsFacadeTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/OperationsFacadeTest.java
@@ -19,6 +19,7 @@
  */
 package org.neo4j.kernel.impl.api;
 
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -57,6 +58,12 @@ public class OperationsFacadeTest
     @Rule
     public ExpectedException expectedException = ExpectedException.none();
 
+    @Before
+    public void setUp() throws Exception
+    {
+        operationsFacade.initialize( statementOperationParts );
+    }
+
     @Test
     public void testThrowExceptionWhenIndexNotFoundByLabelAndProperty() throws SchemaRuleNotFoundException
     {
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/StatementLifecycleTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/StatementLifecycleTest.java
index b3006c68b5d3..c24f54fdb434 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/StatementLifecycleTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/StatementLifecycleTest.java
@@ -69,6 +69,6 @@ public void shouldReleaseStoreStatementWhenForceClosingStatements() throws Excep
     private KernelStatement getKernelStatement( KernelTransactionImplementation transaction,
             StorageStatement storageStatement )
     {
-        return new KernelStatement( transaction, null, null, storageStatement, new Procedures() );
+        return new KernelStatement( transaction, null, storageStatement, new Procedures() );
     }
 }
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/GuardIT.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/GuardIT.java
index 3aba57088d87..008034eccfa9 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/GuardIT.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/GuardIT.java
@@ -26,12 +26,14 @@
 import org.neo4j.kernel.guard.Guard;
 import org.neo4j.kernel.guard.TimeoutGuard;
 import org.neo4j.kernel.impl.api.GuardingStatementOperations;
+import org.neo4j.kernel.impl.api.StatementOperationContainer;
 import org.neo4j.kernel.impl.api.StatementOperationParts;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
 import org.neo4j.test.TestGraphDatabaseFactory;
 import org.neo4j.test.rule.CleanupRule;
 
 import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.not;
 import static org.junit.Assert.assertThat;
 
 public class GuardIT
@@ -50,15 +52,27 @@ public void useTimeoutGuard() throws Exception
     }
 
     @Test
-    public void includeGuardingOperationLayer() throws Exception
+    public void includeGuardingOperationLayerOnGuardingParts() throws Exception
     {
         GraphDatabaseAPI database = startDataBase();
 
         DependencyResolver dependencyResolver = database.getDependencyResolver();
-        StatementOperationParts operationParts =
-                dependencyResolver.resolveDependency( StatementOperationParts.class );
-        assertThat( operationParts.entityReadOperations(), instanceOf( GuardingStatementOperations.class ) );
-        assertThat( operationParts.entityWriteOperations(), instanceOf( GuardingStatementOperations.class ) );
+        StatementOperationContainer operationParts = dependencyResolver.resolveDependency( StatementOperationContainer.class );
+        StatementOperationParts guardedParts = operationParts.guardedParts();
+        assertThat( guardedParts.entityReadOperations(), instanceOf( GuardingStatementOperations.class ) );
+        assertThat( guardedParts.entityWriteOperations(), instanceOf( GuardingStatementOperations.class ) );
+    }
+
+    @Test
+    public void notIncludeGuardingOperationLayerOnNonGuardingParts() throws Exception
+    {
+        GraphDatabaseAPI database = startDataBase();
+
+        DependencyResolver dependencyResolver = database.getDependencyResolver();
+        StatementOperationContainer operationParts = dependencyResolver.resolveDependency( StatementOperationContainer.class );
+        StatementOperationParts guardedParts = operationParts.nonGuarderParts();
+        assertThat( guardedParts.entityReadOperations(), not( instanceOf( GuardingStatementOperations.class ) ) );
+        assertThat( guardedParts.entityWriteOperations(), not( instanceOf( GuardingStatementOperations.class ) ) );
     }
 
     private GraphDatabaseAPI startDataBase()
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerTest.java
index 3d2f20ea9ff0..42ce2786a8a2 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/api/store/DiskLayerTest.java
@@ -65,7 +65,7 @@ public void before()
         db = (GraphDatabaseAPI) createGraphDatabase();
         DependencyResolver resolver = db.getDependencyResolver();
         this.disk = resolver.resolveDependency( StorageEngine.class ).storeReadLayer();
-        this.state = new KernelStatement( null, null, null, disk.newStatement(), new Procedures() );
+        this.state = new KernelStatement( null, null, disk.newStatement(), new Procedures() );
     }
 
     protected GraphDatabaseService createGraphDatabase()
diff --git a/community/server/src/test/java/org/neo4j/server/web/HttpHeaderUtilsTest.java b/community/server/src/test/java/org/neo4j/server/web/HttpHeaderUtilsTest.java
index 24208cd5f49e..bb75fbb1a20c 100644
--- a/community/server/src/test/java/org/neo4j/server/web/HttpHeaderUtilsTest.java
+++ b/community/server/src/test/java/org/neo4j/server/web/HttpHeaderUtilsTest.java
@@ -59,7 +59,7 @@ public void defaultValueWhenCustomTransactionTimeoutNotSpecified()
     {
         Log log = logProvider.getLog( HttpServletRequest.class );
         long transactionTimeout = HttpHeaderUtils.getTransactionTimeout( request, log );
-        assertEquals( "Transaction timeout not specified.", -1, transactionTimeout );
+        assertEquals( "Transaction timeout not specified.", 0, transactionTimeout );
         logProvider.assertNoLoggingOccurred();
     }
 
@@ -69,7 +69,7 @@ public void defaultValueWhenCustomTransactionTimeoutNotANumber()
         when( request.getHeader( HttpHeaderUtils.MAX_EXECUTION_TIME_HEADER ) ).thenReturn( "aa" );
         Log log = logProvider.getLog( HttpServletRequest.class );
         long transactionTimeout = HttpHeaderUtils.getTransactionTimeout( request, log );
-        assertEquals( "Transaction timeout not specified.", -1, transactionTimeout );
+        assertEquals( "Transaction timeout not specified.", 0, transactionTimeout );
         logProvider.assertContainsMessageContaining("Fail to parse `max-execution-time` header with value: 'aa'. Should be a positive number.");
     }
 }