private InternalTransaction beginCustomTransaction( long customTimeout ) { return service.beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED, customTimeout, TimeUnit.MILLISECONDS ); }
private InternalTransaction beginDefaultTransaction() { return service.beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED ); } }
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 ) ); } }
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 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; }
@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 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 ); } }
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 );
@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(); }
when( executingQuery.queryParameters() ).thenReturn( EMPTY_MAP ); when( initialStatement.queryRegistration() ).thenReturn( initialQueryRegistry ); when( queryService.beginTransaction( transactionType, securityContext ) ).thenReturn( secondTransaction ); when( txBridge.getKernelTransactionBoundToThisThread( true ) ).thenReturn( initialKTX,
Mockito.doThrow( RuntimeException.class ).when( initialTransaction ).close(); when( initialStatement.queryRegistration() ).thenReturn( initialQueryRegistry ); when( queryService.beginTransaction( transactionType, securityContext ) ).thenReturn( secondTransaction ); when( txBridge.getKernelTransactionBoundToThisThread( true ) ).thenReturn( initialKTX, initialKTX, secondKTX ); when( txBridge.get() ).thenReturn( secondStatement );
private List<LockOperationRecord> traceQueryLocks( String query, LockOperationListener... listeners ) throws QueryExecutionKernelException { GraphDatabaseQueryService graph = databaseRule.resolveDependency( GraphDatabaseQueryService.class ); QueryExecutionEngine executionEngine = databaseRule.resolveDependency( QueryExecutionEngine.class ); try ( InternalTransaction tx = graph .beginTransaction( KernelTransaction.Type.implicit, LoginContext.AUTH_DISABLED ) ) { TransactionalContextWrapper context = new TransactionalContextWrapper( createTransactionContext( graph, tx, query ), listeners ); executionEngine.executeQuery( query, VirtualValues.emptyMap(), context ); return new ArrayList<>( context.recordingLocks.getLockOperationRecords() ); } }
transaction = graph.beginTransaction( transactionType, securityContext ); kernelTransaction = txBridge.getKernelTransactionBoundToThisThread( true ); statement = kernelTransaction.acquireStatement();
format( "MERGE (%s:Person {id: %s}) ON CREATE SET %s.name = \"%s\";", ident, id, ident, name ); try ( InternalTransaction tx = graph.beginTransaction( KernelTransaction.Type.implicit, LoginContext.AUTH_DISABLED ) )
@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(); } }
private InternalTransaction beginDefaultTransaction() { return service.beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED ); } }
private InternalTransaction beginCustomTransaction( long customTimeout ) { return service.beginTransaction( KernelTransaction.Type.implicit, AUTH_DISABLED, customTimeout, TimeUnit.MILLISECONDS ); }
@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; }