public KernelTransaction transaction() { ensureStarted(); return database.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ) .getKernelTransactionBoundToThisThread( true ); }
QueryRegistryOperations oldQueryRegistryOperations = statement.queryRegistration(); Statement oldStatement = statement; InternalTransaction oldTransaction = transaction; KernelTransaction oldKernelTx = txBridge.getKernelTransactionBoundToThisThread( true ); txBridge.unbindTransactionFromCurrentThread(); kernelTransaction = txBridge.getKernelTransactionBoundToThisThread( true ); statement = kernelTransaction.acquireStatement(); statement.queryRegistration().registerExecutingQuery( executingQuery ); txBridge.unbindTransactionFromCurrentThread(); txBridge.bindTransactionToCurrentThread( oldKernelTx ); oldQueryRegistryOperations.unregisterExecutingQuery( executingQuery ); try oldStatement.close(); oldTransaction.success(); oldTransaction.close(); txBridge.bindTransactionToCurrentThread( kernelTransaction ); transaction.failure(); transaction.close(); txBridge.unbindTransactionFromCurrentThread(); throw t; txBridge.unbindTransactionFromCurrentThread(); txBridge.bindTransactionToCurrentThread( kernelTransaction );
private KernelStatement getKernelStatement( GraphDatabaseAPI db ) { ThreadToStatementContextBridge statementBridge = db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ); return (KernelStatement) statementBridge.get(); } }
void suspendSinceTransactionsAreStillThreadBound() { assert suspendedTransaction == null : "Can't suspend the transaction if it already is suspended."; suspendedTransaction = bridge.getKernelTransactionBoundToThisThread( true ); bridge.unbindTransactionFromCurrentThread(); }
private InternalTransaction beginTransactionInternal( KernelTransaction.Type type, LoginContext loginContext, long timeoutMillis ) { if ( statementContext.hasTransaction() ) { // FIXME: perhaps we should check that the new type and access mode are compatible with the current tx return new PlaceboTransaction( statementContext.getKernelTransactionBoundToThisThread( true ) ); } return new TopLevelTransaction( spi.beginTransaction( type, loginContext, timeoutMillis ) ); }
private Set<IndexEntryUpdate<?>> createSomeBananas( Label label ) { Set<IndexEntryUpdate<?>> updates = new HashSet<>(); try ( Transaction tx = db.beginTx() ) { ThreadToStatementContextBridge ctxSupplier = db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ); KernelTransaction ktx = ctxSupplier.getKernelTransactionBoundToThisThread( true ); int labelId = ktx.tokenRead().nodeLabel( label.name() ); int propertyKeyId = ktx.tokenRead().propertyKey( key ); LabelSchemaDescriptor schemaDescriptor = SchemaDescriptorFactory.forLabel( labelId, propertyKeyId ); for ( int number : new int[]{4, 10} ) { Node node = db.createNode( label ); node.setProperty( key, number ); updates.add( IndexEntryUpdate.add( node.getId(), schemaDescriptor, Values.of( number ) ) ); } tx.success(); return updates; } }
private void getOrCreateIds() throws KernelException { try ( Transaction tx = graphDb.beginTx() ) { ThreadToStatementContextBridge bridge = graphDb.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ); TokenWrite tokenWrite = bridge.getKernelTransactionBoundToThisThread( true ).tokenWrite(); labelId = tokenWrite.labelGetOrCreateForName( "Person" ); relTypeId = tokenWrite.relationshipTypeGetOrCreateForName( "Knows" ); propertyKeyId = tokenWrite.propertyKeyGetOrCreateForName( "name" ); relPropertyKeyId = tokenWrite.propertyKeyGetOrCreateForName( "duration" ); tx.success(); } }
@Override public void compute(String label, String type, int iterations) { degree = new int[nodeCount]; Arrays.fill(degree, -1); try ( Transaction tx = db.beginTx()) { ThreadToStatementContextBridge ctx = this.db.getDependencyResolver().resolveDependency(ThreadToStatementContextBridge.class); ReadOperations ops = ctx.get().readOperations(); int labelId = ops.labelGetForName(label); int relationshipTypeId = ops.relationshipTypeGetForName(type); PrimitiveLongIterator it = ops.nodesGetForLabel(labelId); int totalCount = nodeCount; runOperations(pool, it, totalCount, ops, new OpsRunner() { public void run(int id) throws EntityNotFoundException { degree[id] = ops.nodeGetDegree(id, direction, relationshipTypeId); } }); tx.success(); } catch (Exception e) { e.printStackTrace(); } }
tx.success(); node.setProperty( KEY, VALUE ); tx.success(); tx.success(); KernelTransaction ktx = ((GraphDatabaseAPI) db).getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ).getKernelTransactionBoundToThisThread( true ); IndexReference index = ktx.schemaRead().index( ktx.tokenRead().nodeLabel( LABEL ), ktx.tokenRead().propertyKey( KEY ) ); NodeValueIndexCursor cursor = ktx.cursors().allocateNodeValueIndexCursor(); ktx.dataRead().nodeIndexSeek( index, cursor, IndexOrder.NONE, false, IndexQuery.exact( 1, VALUE ) ); assertTrue( cursor.next() ); assertEquals( node.getId(), cursor.nodeReference() ); assertFalse( cursor.next() ); tx.success();
try ( Transaction tx = db.beginTx() ) node.addLabel( myLabel ); tx.success(); try ( Transaction tx = db.beginTx() ) ctxSupplier.getKernelTransactionBoundToThisThread( true ); TokenRead tokenRead = ktx.tokenRead(); int propertyKey1 = tokenRead.propertyKey( indexProperty ); LabelSchemaDescriptor descriptor = SchemaDescriptorFactory.forLabel( label, propertyKey1 ); assertThat( writer.updatesCommitted, equalTo( asSet( IndexEntryUpdate.add( node.getId(), descriptor, Values.of( value ) ) ) ) ); tx.success();
Supplier<KernelTransaction> ktxSupplier = () -> graphDb.getDependencyResolver() .resolveDependency( ThreadToStatementContextBridge.class ).getKernelTransactionBoundToThisThread( true ); try ( Transaction tx = graphDb.beginTx() ) graphDb.schema().constraintFor( label ).assertPropertyIsUnique( propertyKey ).create(); tx.success(); try ( Transaction transaction = db.beginTx() ) db.createNode( label ).setProperty( propertyKey, conflictingValue ); transaction.success(); tx.success();
@Test public void mixingBeansApiWithKernelAPI() throws Exception { // 1: Start your transactions through the Beans API Transaction transaction = db.beginTx(); // 2: Get a hold of a KernelAPI transaction this way: KernelTransaction ktx = statementContextSupplier.getKernelTransactionBoundToThisThread( true ); // 3: Now you can interact through both the statement context and the kernel API to manipulate the // same transaction. Node node = db.createNode(); int labelId = ktx.tokenWrite().labelGetOrCreateForName( "labello" ); ktx.dataWrite().nodeAddLabel( node.getId(), labelId ); // 4: Commit through the beans API transaction.success(); transaction.close(); }
@Override public void accept( DbStructureVisitor visitor ) { try ( Transaction tx = db.beginTx() ) { showStructure( bridge.getKernelTransactionBoundToThisThread( true ), visitor ); tx.success(); } }
private String getOrCreateSchemaState( String key, final String maybeSetThisState ) { try ( Transaction tx = db.beginTx() ) { KernelTransaction ktx = statementContextSupplier.getKernelTransactionBoundToThisThread( true ); String state = ktx.schemaRead().schemaStateGetOrCreate( key, s -> maybeSetThisState ); tx.success(); return state; } }
try ( Transaction tx = db.beginTx() ) db.createNode( B ); tx.success(); try ( Transaction tx = db.beginTx() ) db.createNode( C ); tx.success(); assertTrue( fs.fileExists( betaStoreFile() ) ); final PageCache pageCache = db.getDependencyResolver().resolveDependency( PageCache.class ); try ( Lifespan life = new Lifespan() ) final CountsTracker tracker = db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ) .testAccessNeoStores().getCounts(); assertEquals( 1 + 1, tracker.nodeCount( -1, newDoubleLongRegister() ).readSecond() ); db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ).getKernelTransactionBoundToThisThread( true ); labelId = transaction.tokenRead().nodeLabel( C.name() );
public void writeBackResults(GraphDatabaseService db, Algorithm algorithm) { ThreadToStatementContextBridge ctx = ((GraphDatabaseAPI)db).getDependencyResolver().resolveDependency(ThreadToStatementContextBridge.class); int propertyNameId; try (Transaction tx = db.beginTx()) { propertyNameId = ctx.get().tokenWriteOperations().propertyKeyGetOrCreateForName(algorithm.getPropertyName()); tx.success(); } catch (IllegalTokenNameException e) { throw new RuntimeException(e);
private void runTransaction( LoginContext loginContext, Map<String,Object> metaData ) { try ( Transaction transaction = db.beginTransaction( KernelTransaction.Type.explicit, loginContext ); Statement statement = db.getDependencyResolver().resolveDependency( ThreadToStatementContextBridge.class ).get() ) { statement.queryRegistration().setMetaData( metaData ); db.createNode(); transaction.success(); } }
private Node createTestNode() { Node node; try ( Transaction transaction = dbRule.beginTx() ) { node = dbRule.createNode( LABEL); KernelTransaction ktx = dbRule.getDependencyResolver() .resolveDependency( ThreadToStatementContextBridge.class ) .getKernelTransactionBoundToThisThread( true ); labelId = ktx.tokenRead().nodeLabel( LABEL.name() ); transaction.success(); } return node; }
public long countNodes() { long result; try ( Transaction tx = graph.beginTransaction( KernelTransaction.Type.explicit, AnonymousContext.read() ) ) { KernelTransaction kernelTransaction = this.txBridge.getKernelTransactionBoundToThisThread(true ); result = kernelTransaction.dataRead().countsForNode( -1 ); tx.success(); } return result; } }
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 ); } }