Removed DbmsOperations.Factory, which is no longer needed

community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_0/TransactionBoundQueryContext.scala

@@ -623,7 +623,7 @@ final class TransactionBoundQueryContext(val transactionalContext: Transactional
     callProcedure(name, args, transactionalContext.statement.dataWriteOperations().procedureCallWrite)
 
   override def callDbmsProcedure(name: QualifiedProcedureName, args: Seq[Any]) =
-    callProcedure(name, args, transactionalContext.dbmsOperations.procedureCallDbms)
+    callProcedure(name, args, transactionalContext.dbmsOperations.procedureCallDbms(_,_,transactionalContext.accessMode))
 
   private def callProcedure(name: QualifiedProcedureName, args: Seq[Any],
                             call: (QualifiedName, Array[AnyRef]) => RawIterator[Array[AnyRef], ProcedureException]) = {

community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundQueryContext.scala

@@ -614,7 +614,7 @@ final class TransactionBoundQueryContext(val transactionalContext: Transactional
   }
 
   override def callDbmsProcedure(name: QualifiedName, args: Seq[Any], allowed: Array[String]) = {
-    callProcedure(name, args, transactionalContext.dbmsOperations.procedureCallDbms, ())
+    callProcedure(name, args, transactionalContext.dbmsOperations.procedureCallDbms(_,_,transactionalContext.accessMode), ())
   }
 
   private def callProcedure(name: QualifiedName, args: Seq[Any],

community/kernel/src/main/java/org/neo4j/kernel/api/dbms/DbmsOperations.java

@@ -21,9 +21,9 @@
 
 import org.neo4j.collection.RawIterator;
 import org.neo4j.kernel.api.KernelAPI;
-import org.neo4j.kernel.api.KernelTransaction;
 import org.neo4j.kernel.api.exceptions.ProcedureException;
 import org.neo4j.kernel.api.proc.QualifiedName;
+import org.neo4j.kernel.api.security.AccessMode;
 
 /**
  * Defines all types of system-oriented operations - i.e. those which do not read from or write to the graph - that can be done from the {@link KernelAPI}.
@@ -36,13 +36,16 @@ public interface DbmsOperations
     //=================================================
 
     /** Invoke a DBMS procedure by name */
-    RawIterator<Object[],ProcedureException> procedureCallDbms( QualifiedName name, Object[] input )
-            throws ProcedureException;
-   Object functionCallDbms( QualifiedName name, Object[] input )
-            throws ProcedureException;
+    RawIterator<Object[],ProcedureException> procedureCallDbms(
+            QualifiedName name,
+            Object[] input,
+            AccessMode mode
+    ) throws ProcedureException;
 
-    interface Factory
-    {
-        DbmsOperations newInstance( KernelTransaction tx );
-    }
+    /** Invoke a DBMS function by name */
+    Object functionCallDbms(
+            QualifiedName name,
+            Object[] input,
+            AccessMode mode
+    ) throws ProcedureException;
 }

community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/BuiltInProcedures.java

@@ -51,7 +51,7 @@
 import static org.neo4j.helpers.collection.Iterators.asSet;
 import static org.neo4j.procedure.Mode.READ;
 
-@SuppressWarnings( "unused" )
+@SuppressWarnings( {"unused", "WeakerAccess"} )
 public class BuiltInProcedures
 {
     @Context

community/kernel/src/main/java/org/neo4j/kernel/impl/api/dbms/NonTransactionalDbmsOperations.java

@@ -20,11 +20,9 @@
 package org.neo4j.kernel.impl.api.dbms;
 
 import org.neo4j.collection.RawIterator;
-import org.neo4j.kernel.api.KernelTransaction;
 import org.neo4j.kernel.api.dbms.DbmsOperations;
 import org.neo4j.kernel.api.exceptions.ProcedureException;
 import org.neo4j.kernel.api.proc.BasicContext;
-import org.neo4j.kernel.api.proc.CallableProcedure;
 import org.neo4j.kernel.api.proc.Context;
 import org.neo4j.kernel.api.proc.QualifiedName;
 import org.neo4j.kernel.api.security.AccessMode;
@@ -35,21 +33,20 @@ public class NonTransactionalDbmsOperations implements DbmsOperations
 {
 
     private final Procedures procedures;
-    private final KernelTransaction transaction;
 
-    public NonTransactionalDbmsOperations( Procedures procedures, KernelTransaction transaction )
+    public NonTransactionalDbmsOperations( Procedures procedures )
     {
         this.procedures = procedures;
-        this.transaction = transaction;
     }
 
     @Override
-    public RawIterator<Object[],ProcedureException> procedureCallDbms( QualifiedName name,
-            Object[] input ) throws ProcedureException
+    public RawIterator<Object[],ProcedureException> procedureCallDbms(
+            QualifiedName name,
+            Object[] input,
+            AccessMode mode
+    ) throws ProcedureException
     {
         BasicContext ctx = new BasicContext();
-        ctx.put( Context.KERNEL_TRANSACTION, transaction );
-        AccessMode mode = transaction.mode();
         if ( mode instanceof AuthSubject )
         {
             ctx.put( Context.AUTH_SUBJECT, (AuthSubject) mode );
@@ -58,32 +55,18 @@ public RawIterator<Object[],ProcedureException> procedureCallDbms( QualifiedName
     }
 
     @Override
-    public Object functionCallDbms( QualifiedName name,
-            Object[] input ) throws ProcedureException
+    public Object functionCallDbms(
+            QualifiedName name,
+            Object[] input,
+            AccessMode mode
+    ) throws ProcedureException
     {
         BasicContext ctx = new BasicContext();
-        ctx.put( Context.KERNEL_TRANSACTION, transaction );
-        if ( transaction.mode() instanceof AuthSubject )
+        if ( mode instanceof AuthSubject )
         {
-            AuthSubject subject = (AuthSubject) transaction.mode();
+            AuthSubject subject = (AuthSubject) mode;
             ctx.put( Context.AUTH_SUBJECT, subject );
         }
         return procedures.callFunction( ctx, name, input );
     }
-
-    public static class Factory implements DbmsOperations.Factory
-    {
-        private final Procedures procedures;
-
-        public Factory( Procedures procedures )
-        {
-            this.procedures = procedures;
-        }
-
-        @Override
-        public DbmsOperations newInstance( KernelTransaction tx )
-        {
-            return new NonTransactionalDbmsOperations( procedures, tx );
-        }
-    }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/factory/DataSourceModule.java

@@ -172,7 +172,7 @@ public DataSourceModule( final PlatformModule platformModule, EditionModule edit
 
         Procedures procedures = setupProcedures( platformModule, editionModule );
 
-        deps.satisfyDependency( new NonTransactionalDbmsOperations.Factory( procedures ) );
+        deps.satisfyDependency( new NonTransactionalDbmsOperations( procedures ) );
 
         NonTransactionalTokenNameLookup tokenNameLookup = new NonTransactionalTokenNameLookup(
                 editionModule.labelTokenHolder,

community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContext.java

@@ -46,7 +46,7 @@ public class Neo4jTransactionalContext implements TransactionalContext
     private final KernelTransaction.Type transactionType;
     private final AccessMode mode;
     private final Supplier<Statement> statementSupplier;
-    private final DbmsOperations.Factory dbmsOperationsFactory;
+    private final DbmsOperations dbmsOperations;
     private final Guard guard;
     private final ExecutingQuery executingQuery;
     private final PropertyContainerLocker locker;
@@ -64,7 +64,7 @@ public Neo4jTransactionalContext(
             ExecutingQuery executingQuery,
             PropertyContainerLocker locker,
             ThreadToStatementContextBridge txBridge,
-            DbmsOperations.Factory dbmsOperationsFactory,
+            DbmsOperations dbmsOperations,
             Guard guard
     ) {
         this.graph = graph;
@@ -76,7 +76,7 @@ public Neo4jTransactionalContext(
         this.executingQuery = executingQuery;
         this.locker = locker;
         this.txBridge = txBridge;
-        this.dbmsOperationsFactory = dbmsOperationsFactory;
+        this.dbmsOperations = dbmsOperations;
         this.guard = guard;
     }
 
@@ -95,7 +95,7 @@ public ReadOperations readOperations()
     @Override
     public DbmsOperations dbmsOperations()
     {
-        return dbmsOperationsFactory.newInstance( txBridge.getKernelTransactionBoundToThisThread( true ) );
+        return dbmsOperations;
     }
 
     @Override

community/kernel/src/main/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContextFactory.java

@@ -40,7 +40,7 @@ public class Neo4jTransactionalContextFactory implements TransactionalContextFac
     private final Supplier<GraphDatabaseQueryService> queryServiceSupplier;
     private final ThreadToStatementContextBridge txBridge;
     private final PropertyContainerLocker locker;
-    private final DbmsOperations.Factory dbmsOpsFactory;
+    private final DbmsOperations dbmsOperations;
     private final Guard guard;
 
     public Neo4jTransactionalContextFactory( GraphDatabaseFacade.SPI spi, PropertyContainerLocker locker )
@@ -63,7 +63,7 @@ public Neo4jTransactionalContextFactory( GraphDatabaseQueryService queryService,
                 statementSupplier,
                 queryService.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ),
                 locker,
-                queryService.getDependencyResolver().resolveDependency( DbmsOperations.Factory.class ),
+                queryService.getDependencyResolver().resolveDependency( DbmsOperations.class ),
                 queryService.getDependencyResolver().resolveDependency( Guard.class )
         );
     }
@@ -75,7 +75,7 @@ public Neo4jTransactionalContextFactory( PropertyContainerLocker locker, Supplie
                 statementSupplier,
                 resolver.resolveDependency( ThreadToStatementContextBridge.class ),
                 locker,
-                resolver.resolveDependency( DbmsOperations.Factory.class ),
+                resolver.resolveDependency( DbmsOperations.class ),
                 resolver.resolveDependency( Guard.class )
         );
     }
@@ -85,14 +85,14 @@ public Neo4jTransactionalContextFactory(
             Supplier<Statement> statementSupplier,
             ThreadToStatementContextBridge txBridge,
             PropertyContainerLocker locker,
-            DbmsOperations.Factory dbmsOpsFactory,
+            DbmsOperations dbmsOperations,
             Guard guard
     ) {
         this.queryServiceSupplier = queryServiceSupplier;
         this.statementSupplier = statementSupplier;
         this.txBridge = txBridge;
         this.locker = locker;
-        this.dbmsOpsFactory = dbmsOpsFactory;
+        this.dbmsOperations = dbmsOperations;
         this.guard = guard;
     }
 
@@ -119,7 +119,7 @@ public Neo4jTransactionalContext newContext(
                 executingQuery,
                 locker,
                 txBridge,
-                dbmsOpsFactory,
+                dbmsOperations,
                 guard
         );
     }

community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/BuiltInProceduresIT.java

@@ -138,7 +138,7 @@ public void failWhenCallingNonExistingProcedures() throws Throwable
         try
         {
             // When
-            dbmsOperations( Static.NONE ).procedureCallDbms( procedureName( "dbms", "iDoNotExist" ), new Object[0] );
+            dbmsOperations().procedureCallDbms( procedureName( "dbms", "iDoNotExist" ), new Object[0], Static.NONE );
             fail( "This should never get here" );
         }
         catch ( Exception e )

community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/KernelIntegrationTest.java

@@ -52,7 +52,7 @@ public abstract class KernelIntegrationTest
     private KernelTransaction transaction;
     private Statement statement;
     private EphemeralFileSystemAbstraction fs;
-    private DbmsOperations.Factory dbmsOperationsFactory;
+    private DbmsOperations dbmsOperations;
 
     protected TokenWriteOperations tokenWriteOperationsInNewTransaction() throws KernelException
     {
@@ -82,11 +82,9 @@ protected ReadOperations readOperationsInNewTransaction() throws TransactionFail
         return statement.readOperations();
     }
 
-    protected DbmsOperations dbmsOperations( AccessMode accessMode ) throws TransactionFailureException
+    protected DbmsOperations dbmsOperations()
     {
-        transaction = kernel.newTransaction( KernelTransaction.Type.implicit, accessMode );
-        statement = transaction.acquireStatement();
-        return dbmsOperationsFactory.newInstance( transaction );
+        return dbmsOperations;
     }
 
     protected void commit() throws TransactionFailureException
@@ -139,7 +137,7 @@ protected void startDb()
         kernel = db.getDependencyResolver().resolveDependency( KernelAPI.class );
         indexingService = db.getDependencyResolver().resolveDependency( IndexingService.class );
         statementContextSupplier = db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class );
-        dbmsOperationsFactory = db.getDependencyResolver().resolveDependency( DbmsOperations.Factory.class );
+        dbmsOperations = db.getDependencyResolver().resolveDependency( DbmsOperations.class );
     }
 
     protected GraphDatabaseService createGraphDatabase( EphemeralFileSystemAbstraction fs )

community/kernel/src/test/java/org/neo4j/kernel/impl/query/Neo4jTransactionalContextTest.java

@@ -66,13 +66,13 @@ public void checkKernelStatementOnCheck() throws Exception
         KernelTransaction.Type transactionType = null;
         AccessMode transactionMode = null;
         ExecutingQuery executingQuery = null;
-        DbmsOperations.Factory dbmsOperationsFactory = null;
+        DbmsOperations dbmsOperations = null;
         ThreadToStatementContextBridge txBridge = null;
 
         Neo4jTransactionalContext transactionalContext =
                 new Neo4jTransactionalContext(
                         databaseQueryService, transaction, transactionType, transactionMode, () -> statement,
-                        executingQuery, propertyContainerLocker, txBridge, dbmsOperationsFactory, guard );
+                        executingQuery, propertyContainerLocker, txBridge, dbmsOperations, guard );
 
         transactionalContext.check();
 
@@ -93,7 +93,7 @@ public void neverStopsExecutingQueryDuringCommitAndRestartTx()
         PropertyContainerLocker locker = null;
         ThreadToStatementContextBridge txBridge = mock( ThreadToStatementContextBridge.class );
         Guard guard = mock( Guard.class );
-        DbmsOperations.Factory dbmsOperationsFactory = null;
+        DbmsOperations dbmsOperations = null;
 
         KernelTransaction secondKTX = mock( KernelTransaction.class );
         InternalTransaction secondTransaction = mock( InternalTransaction.class );
@@ -111,7 +111,7 @@ public void neverStopsExecutingQueryDuringCommitAndRestartTx()
 
         Neo4jTransactionalContext context = new Neo4jTransactionalContext(
                 databaseQueryService, initialTransaction, transactionType, transactionMode, () -> statement,
-                executingQuery, locker, txBridge, dbmsOperationsFactory, guard );
+                executingQuery, locker, txBridge, dbmsOperations, guard );
 
         // When
         context.commitAndRestartTx();
@@ -176,7 +176,7 @@ public void rollsBackNewlyCreatedTransactionIfTerminationDetectedOnCloseDuringPe
         ExecutingQuery executingQuery = mock( ExecutingQuery.class );
         PropertyContainerLocker locker = null;
         ThreadToStatementContextBridge txBridge = mock( ThreadToStatementContextBridge.class );
-        DbmsOperations.Factory dbmsOperationsFactory = null;
+        DbmsOperations dbmsOperations = null;
 
         KernelTransaction secondKTX = mock( KernelTransaction.class );
         InternalTransaction secondTransaction = mock( InternalTransaction.class );
@@ -194,7 +194,7 @@ public void rollsBackNewlyCreatedTransactionIfTerminationDetectedOnCloseDuringPe
 
         Neo4jTransactionalContext context = new Neo4jTransactionalContext(
                 graph, initialTransaction, transactionType, transactionMode, () -> initialStatement, executingQuery,
-                locker, txBridge, dbmsOperationsFactory, guard );
+                locker, txBridge, dbmsOperations, guard );
 
         // When
         try

community/security/src/test/java/org/neo4j/server/security/auth/AuthProceduresTest.java

@@ -47,8 +47,8 @@ public void callDeprecatedChangePasswordWithAccessModeInDbmsMode() throws Throwa
         AuthSubject authSubject = mock( AuthSubject.class );
 
         // When
-        RawIterator<Object[], ProcedureException> stream = dbmsOperations( authSubject )
-                .procedureCallDbms( procedureName( "dbms", "changePassword" ), inputArray );
+        RawIterator<Object[], ProcedureException> stream = dbmsOperations().procedureCallDbms(
+                procedureName( "dbms", "changePassword" ), inputArray, authSubject );
 
         // Then
         verify( authSubject ).setPassword( (String) inputArray[0], false );
@@ -65,7 +65,8 @@ public void shouldFailWhenDeprecatedChangePasswordWithStaticAccessModeInDbmsMode
             inputArray[0] = "newPassword";
 
             // When
-            dbmsOperations( AccessMode.Static.NONE ).procedureCallDbms( procedureName( "dbms", "changePassword" ), inputArray );
+            dbmsOperations().procedureCallDbms(
+                    procedureName( "dbms", "changePassword" ), inputArray, AccessMode.Static.NONE );
             fail( "Should have failed." );
         }
         catch ( Exception e )
@@ -84,8 +85,8 @@ public void callChangePasswordWithAccessModeInDbmsMode() throws Throwable
         AuthSubject authSubject = mock( AuthSubject.class );
 
         // When
-        RawIterator<Object[],ProcedureException> stream = dbmsOperations( authSubject )
-                .procedureCallDbms( procedureName( "dbms", "security", "changePassword" ), inputArray );
+        RawIterator<Object[],ProcedureException> stream = dbmsOperations().procedureCallDbms(
+                procedureName( "dbms", "security", "changePassword" ), inputArray, authSubject );
 
         // Then
         verify( authSubject ).setPassword( (String) inputArray[0], false );
@@ -102,8 +103,8 @@ public void shouldFailWhenChangePasswordWithStaticAccessModeInDbmsMode() throws
             inputArray[0] = "newPassword";
 
             // When
-            dbmsOperations( AccessMode.Static.NONE )
-                    .procedureCallDbms( procedureName( "dbms", "security", "changePassword" ), inputArray );
+            dbmsOperations().procedureCallDbms(
+                    procedureName( "dbms", "security", "changePassword" ), inputArray, AccessMode.Static.NONE );
             fail( "Should have failed." );
         }
         catch ( Exception e )