private InternalTransaction beginCustomTransaction( long customTimeout ) { return service.beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED, customTimeout, TimeUnit.MILLISECONDS ); }
private void setUpMocks() { queryService = mock( GraphDatabaseQueryService.class ); DependencyResolver resolver = mock( DependencyResolver.class ); txBridge = mock( ThreadToStatementContextBridge.class ); initialStatement = mock( KernelStatement.class ); statistics = new ConfiguredExecutionStatistics(); QueryRegistryOperations queryRegistryOperations = mock( QueryRegistryOperations.class ); InternalTransaction internalTransaction = mock( InternalTransaction.class ); when( internalTransaction.terminationReason() ).thenReturn( Optional.empty() ); when( initialStatement.queryRegistration() ).thenReturn( queryRegistryOperations ); when( queryService.getDependencyResolver() ).thenReturn( resolver ); when( resolver.resolveDependency( ThreadToStatementContextBridge.class ) ).thenReturn( txBridge ); when( queryService.beginTransaction( any(), any() ) ).thenReturn( internalTransaction ); KernelTransaction mockTransaction = mockTransaction( initialStatement ); when( txBridge.get() ).thenReturn( initialStatement ); when( txBridge.getKernelTransactionBoundToThisThread(true ) ).thenReturn( mockTransaction ); }
@Override public DbmsOperations dbmsOperations() { return graph.getDbmsOperations(); }
private static DatabaseManager newDbMock() { GraphDatabaseFacade db = mock( GraphDatabaseFacade.class ); DependencyResolver dependencyResolver = mock( DependencyResolver.class ); when( db.getDependencyResolver() ).thenReturn( dependencyResolver ); GraphDatabaseQueryService queryService = mock( GraphDatabaseQueryService.class ); when( queryService.getDependencyResolver() ).thenReturn( dependencyResolver ); when( dependencyResolver.resolveDependency( GraphDatabaseQueryService.class ) ).thenReturn( queryService ); DatabaseManager databaseManager = mock( DatabaseManager.class ); when( databaseManager.getDatabaseFacade( CUSTOM_DB_NAME ) ).thenReturn( Optional.of( db ) ); return databaseManager; } }
@Deprecated public static TransactionalContextFactory create( GraphDatabaseQueryService queryService, PropertyContainerLocker locker ) { DependencyResolver resolver = queryService.getDependencyResolver(); ThreadToStatementContextBridge txBridge = resolver.resolveDependency( ThreadToStatementContextBridge.class ); Kernel kernel = resolver.resolveDependency( Kernel.class ); Neo4jTransactionalContext.Creator contextCreator = ( tx, initialStatement, executingQuery ) -> new Neo4jTransactionalContext( queryService, txBridge, locker, tx, initialStatement, executingQuery, kernel ); return new Neo4jTransactionalContextFactory( txBridge, contextCreator ); }
private InternalTransaction beginDefaultTransaction() { return service.beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED ); } }
when( resolver.resolveDependency( ThreadToStatementContextBridge.class ) ).thenReturn( statementBridge ); when( resolver.resolveDependency( GraphDatabaseQueryService.class ) ).thenReturn( databaseQueryService ); when( databaseQueryService.beginTransaction( type, loginContext ) ).thenReturn( transaction ); when( databaseQueryService.beginTransaction( type, loginContext, CUSTOM_TRANSACTION_TIMEOUT, TimeUnit.MILLISECONDS ) ).thenReturn( transaction ); when( databaseQueryService.getDependencyResolver() ).thenReturn( resolver ); when( request.getScheme() ).thenReturn( "http" ); when( request.getRemoteAddr() ).thenReturn( "127.0.0.1" );
private static TransactionStateMachineV1SPI createTxSpi( Supplier<TransactionIdStore> txIdStore, Duration txAwaitDuration, DatabaseAvailabilityGuard availabilityGuard, Clock clock ) { QueryExecutionEngine queryExecutionEngine = mock( QueryExecutionEngine.class ); DependencyResolver dependencyResolver = mock( DependencyResolver.class ); ThreadToStatementContextBridge bridge = new ThreadToStatementContextBridge( availabilityGuard ); when( dependencyResolver.resolveDependency( ThreadToStatementContextBridge.class ) ).thenReturn( bridge ); when( dependencyResolver.resolveDependency( QueryExecutionEngine.class ) ).thenReturn( queryExecutionEngine ); when( dependencyResolver.resolveDependency( DatabaseAvailabilityGuard.class ) ).thenReturn( availabilityGuard ); when( dependencyResolver.provideDependency( TransactionIdStore.class ) ).thenReturn( txIdStore ); GraphDatabaseAPI db = mock( GraphDatabaseAPI.class ); when( db.getDependencyResolver() ).thenReturn( dependencyResolver ); GraphDatabaseQueryService queryService = mock( GraphDatabaseQueryService.class ); when( queryService.getDependencyResolver() ).thenReturn( dependencyResolver ); when( dependencyResolver.resolveDependency( GraphDatabaseQueryService.class ) ).thenReturn( queryService ); BoltChannel boltChannel = new BoltChannel( "bolt-42", "bolt", new EmbeddedChannel() ); return new TransactionStateMachineV1SPI( db, boltChannel, txAwaitDuration, clock ); } }
@Override public DbmsOperations dbmsOperations() { return graph.getDbmsOperations(); }
public TransactionalContext create( HttpServletRequest request, GraphDatabaseQueryService service, Type type, LoginContext loginContext, String query, Map<String, Object> queryParameters ) { TransactionalContextFactory contextFactory = Neo4jTransactionalContextFactory.create( service, locker ); ClientConnectionInfo clientConnection = HttpConnectionInfoFactory.create( request ); InternalTransaction transaction = service.beginTransaction( type, loginContext ); return contextFactory.newContext( clientConnection, transaction, query, ValueUtils.asMapValue( queryParameters ) ); } }
@Test public void shouldConvertListsAndMapsWhenPassingFromScalaToJava() throws Exception { GraphDatabaseQueryService graph = new GraphDatabaseCypherService( this.database.getGraphDatabaseAPI() ); DependencyResolver resolver = graph.getDependencyResolver(); Monitors monitors = resolver.resolveDependency( Monitors.class ); NullLogProvider nullLogProvider = NullLogProvider.getInstance(); Config config = resolver.resolveDependency( Config.class ); CypherConfiguration cypherConfig = CypherConfiguration.fromConfig( config ); CommunityCompilerFactory compilerFactory = new CommunityCompilerFactory( graph, monitors, nullLogProvider, cypherConfig.toCypherPlannerConfiguration( config ), cypherConfig.toCypherRuntimeConfiguration() ); ExecutionEngine executionEngine = new ExecutionEngine( graph, nullLogProvider, compilerFactory ); Result result; try ( InternalTransaction tx = graph .beginTransaction( KernelTransaction.Type.implicit, LoginContext.AUTH_DISABLED ) ) { String query = "RETURN { key : 'Value' , collectionKey: [{ inner: 'Map1' }, { inner: 'Map2' }]}"; TransactionalContext tc = createTransactionContext( graph, tx, query ); result = executionEngine.executeQuery( query, NO_PARAMS, tc ); verifyResult( result ); result.close(); tx.success(); } }
/** * Creates an execution engine around the give graph database * @param queryService The database to wrap * @param logProvider A {@link LogProvider} for cypher-statements */ public ExecutionEngine( GraphDatabaseQueryService queryService, LogProvider logProvider, CompilerFactory compilerFactory ) { DependencyResolver resolver = queryService.getDependencyResolver(); Monitors monitors = resolver.resolveDependency( Monitors.class ); CacheTracer cacheTracer = new MonitoringCacheTracer( monitors.newMonitor( StringCacheMonitor.class ) ); Config config = resolver.resolveDependency( Config.class ); CypherConfiguration cypherConfiguration = CypherConfiguration.fromConfig( config ); CompilationTracer tracer = new TimingCompilationTracer( monitors.newMonitor( TimingCompilationTracer.EventListener.class ) ); inner = new org.neo4j.cypher.internal.ExecutionEngine( queryService, monitors, tracer, cacheTracer, cypherConfiguration, compilerFactory, logProvider, Clock.systemUTC() ); }
@Override public TransactionalContext getOrBeginNewIfClosed() { checkNotTerminated(); if ( !isOpen ) { transaction = graph.beginTransaction( transactionType, securityContext ); kernelTransaction = txBridge.getKernelTransactionBoundToThisThread( true ); statement = kernelTransaction.acquireStatement(); statement.queryRegistration().registerExecutingQuery( executingQuery ); isOpen = true; } return this; }
@Deprecated public static TransactionalContextFactory create( GraphDatabaseQueryService queryService, PropertyContainerLocker locker ) { DependencyResolver resolver = queryService.getDependencyResolver(); ThreadToStatementContextBridge txBridge = resolver.resolveDependency( ThreadToStatementContextBridge.class ); Kernel kernel = resolver.resolveDependency( Kernel.class ); Neo4jTransactionalContext.Creator contextCreator = ( tx, initialStatement, executingQuery ) -> new Neo4jTransactionalContext( queryService, txBridge, locker, tx, initialStatement, executingQuery, kernel ); return new Neo4jTransactionalContextFactory( txBridge, contextCreator ); }
@Test void executeQueryStartDefaultTransaction() { KernelTransaction kernelTransaction = mock( KernelTransaction.class ); InternalTransaction transaction = new TopLevelTransaction( kernelTransaction ); when( queryService.beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED ) ) .thenReturn( transaction ); graphDatabaseFacade.execute( "create (n)" ); graphDatabaseFacade.execute( "create (n)", new HashMap<>() ); long timeout = Config.defaults().get( GraphDatabaseSettings.transaction_timeout ).toMillis(); verify( spi, times( 2 ) ).beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED, timeout ); } }
/** * Creates an execution engine around the give graph database * @param queryService The database to wrap * @param logProvider A {@link LogProvider} for cypher-statements */ public ExecutionEngine( GraphDatabaseQueryService queryService, LogProvider logProvider, CompilerFactory compilerFactory ) { DependencyResolver resolver = queryService.getDependencyResolver(); Monitors monitors = resolver.resolveDependency( Monitors.class ); CacheTracer cacheTracer = new MonitoringCacheTracer( monitors.newMonitor( StringCacheMonitor.class ) ); Config config = resolver.resolveDependency( Config.class ); CypherConfiguration cypherConfiguration = CypherConfiguration.fromConfig( config ); CompilationTracer tracer = new TimingCompilationTracer( monitors.newMonitor( TimingCompilationTracer.EventListener.class ) ); inner = new org.neo4j.cypher.internal.ExecutionEngine( queryService, monitors, tracer, cacheTracer, cypherConfiguration, compilerFactory, logProvider, Clock.systemUTC() ); }
@Test public void startTransactionWithCustomTimeout() { when( request.getHeader( HttpHeaderUtils.MAX_EXECUTION_TIME_HEADER ) ) .thenReturn( String.valueOf( CUSTOM_TRANSACTION_TIMEOUT ) ); CypherExecutor cypherExecutor = new CypherExecutor( database, logProvider ); cypherExecutor.start(); cypherExecutor.createTransactionContext( QUERY, VirtualValues.emptyMap(), request ); verify( databaseQueryService ).beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED, CUSTOM_TRANSACTION_TIMEOUT, TimeUnit.MILLISECONDS ); logProvider.assertNoLoggingOccurred(); }
@Test public void startDefaultTransactionWhenHeaderHasIncorrectValue() { when( request.getHeader( HttpHeaderUtils.MAX_EXECUTION_TIME_HEADER ) ) .thenReturn( "not a number" ); CypherExecutor cypherExecutor = new CypherExecutor( database, logProvider ); cypherExecutor.start(); cypherExecutor.createTransactionContext( QUERY, VirtualValues.emptyMap(), request ); verify( databaseQueryService ).beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED ); logProvider.assertContainsMessageContaining( "Fail to parse `max-execution-time` header with value: 'not a " + "number'. Should be a positive number." ); }
@Test public void startDefaultTransactionIfTimeoutIsNegative() { when( request.getHeader( HttpHeaderUtils.MAX_EXECUTION_TIME_HEADER ) ) .thenReturn( "-2" ); CypherExecutor cypherExecutor = new CypherExecutor( database, logProvider ); cypherExecutor.start(); cypherExecutor.createTransactionContext( QUERY, VirtualValues.emptyMap(), request ); verify( databaseQueryService ).beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED ); logProvider.assertNoLoggingOccurred(); }
@Test public void startDefaultTransaction() { CypherExecutor cypherExecutor = new CypherExecutor( database, logProvider ); cypherExecutor.start(); cypherExecutor.createTransactionContext( QUERY, VirtualValues.emptyMap(), request ); verify( databaseQueryService ).beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED ); logProvider.assertNoLoggingOccurred(); }