public IndexProcedures( KernelTransaction tx, IndexingService indexingService ) { this.ktx = tx; statement = tx.acquireStatement(); this.indexingService = indexingService; }
@Override public Statement get() { return getKernelTransactionBoundToThisThread( true ).acquireStatement(); }
@Override public Statement acquireStatement() { return internal.acquireStatement(); }
@Override public IndexHits<T> query( String key, Object queryOrQueryObject ) { KernelTransaction ktx = txBridge.get(); try ( Statement ignore = ktx.acquireStatement() ) { return type.query( ktx, name, key, queryOrQueryObject, gds ); } catch ( ExplicitIndexNotFoundKernelException e ) { throw new NotFoundException( type + " index '" + name + "' doesn't exist" ); } }
@Override public IndexHits<T> get( String key, Object value ) { KernelTransaction ktx = txBridge.get(); try ( Statement ignore = ktx.acquireStatement() ) { return internalGet( key, value, ktx ) ; } catch ( ExplicitIndexNotFoundKernelException e ) { throw new NotFoundException( type + " index '" + name + "' doesn't exist" ); } }
@Override public String getUserMessage( KernelException e ) { KernelTransaction transaction = safeAcquireTransaction( transactionSupplier ); try ( Statement ignore = transaction.acquireStatement() ) { return e.getUserMessage( new SilentTokenNameLookup( transaction.tokenRead() ) ); } }
FakeBridge() { super( mock( AvailabilityGuard.class ) ); when( tx.acquireStatement() ).thenReturn( statement ); when( statement.hasTxStateWithChanges() ).thenReturn( false ); }
/** * You MUST hold a schema write lock before you call this method. */ public void dropUniquenessConstraintIndex( IndexDescriptor descriptor ) throws TransactionFailureException { try ( Transaction transaction = kernelSupplier.get().beginTransaction( implicit, AUTH_DISABLED ); Statement ignore = ((KernelTransaction)transaction).acquireStatement() ) { ((KernelTransactionImplementation) transaction).txState().indexDoDrop( descriptor ); transaction.success(); } }
@Override public Iterable<IndexDefinition> getIndexes() { KernelTransaction transaction = transactionSupplier.get(); SchemaRead schemaRead = transaction.schemaRead(); try ( Statement ignore = transaction.acquireStatement() ) { List<IndexDefinition> definitions = new ArrayList<>(); Iterator<IndexReference> indexes = schemaRead.indexesGetAll(); addDefinitions( definitions, transaction.tokenRead(), IndexReference.sortByType( indexes ) ); return definitions; } }
private TokenIterator( KernelTransaction transaction, TokenAccess<T> access ) { this.access = access; this.statement = transaction.acquireStatement(); try { this.tokens = access.tokens( transaction.tokenRead() ); } catch ( Exception e ) { close(); throw e; } }
private KernelTransaction mockTransaction( Statement statement ) { KernelTransaction kernelTransaction = mock( KernelTransaction.class, new ReturnsDeepStubs() ); when( kernelTransaction.executionStatistics() ).thenReturn( statistics ); when( kernelTransaction.acquireStatement() ).thenReturn( statement ); return kernelTransaction; }
@Test public void closeStatementOnClose() { KernelTransaction kernelTransaction = mock( KernelTransaction.class ); Statement statement = mock( Statement.class ); when( kernelTransaction.acquireStatement() ).thenReturn( statement ); //noinspection EmptyTryBlock try ( IndexProcedures ignored = new IndexProcedures( kernelTransaction, null ) ) { } verify( statement ).close(); } }
@Override public Iterable<ConstraintDefinition> getConstraints() { KernelTransaction transaction = safeAcquireTransaction( transactionSupplier ); try ( Statement ignore = transaction.acquireStatement() ) { return asConstraintDefinitions( transaction.schemaRead().constraintsGetAll(), transaction.tokenRead() ); } }
@Override public int getDegree() { KernelTransaction transaction = safeAcquireTransaction(); try ( Statement ignore = transaction.acquireStatement() ) { NodeCursor nodes = transaction.ambientNodeCursor(); singleNode( transaction, nodes ); return Nodes.countAll( nodes, transaction.cursors() ); } }
@Override public Node createNode() { KernelTransaction transaction = statementContext.getKernelTransactionBoundToThisThread( true ); try ( Statement ignore = transaction.acquireStatement() ) { return newNodeProxy( transaction.dataWrite().nodeCreate() ); } catch ( InvalidTransactionTypeKernelException e ) { throw new ConstraintViolationException( e.getMessage(), e ); } }
private int getPropertyIdByName( String name ) { ThreadToStatementContextBridge transactionStatementContextBridge = getTransactionStatementContextBridge(); KernelTransaction ktx = transactionStatementContextBridge.getKernelTransactionBoundToThisThread( true ); try ( Statement ignore = ktx.acquireStatement() ) { return ktx.tokenRead().propertyKey( name ); } }
public static TransactionStateChecker create( TransitionalPeriodTransactionMessContainer container ) { KernelTransaction topLevelTransactionBoundToThisThread = container.getBridge().getKernelTransactionBoundToThisThread( true ); KernelStatement kernelStatement = (KernelStatement) topLevelTransactionBoundToThisThread.acquireStatement(); return new TransactionStateChecker( kernelStatement, nodeId -> kernelStatement.hasTxStateWithChanges() && kernelStatement.txState().nodeIsDeletedInThisTx( nodeId ), relId -> kernelStatement.hasTxStateWithChanges() && kernelStatement.txState().relationshipIsDeletedInThisTx( relId ) ); }
private void dropIndex( IndexReference index ) throws KernelException { try ( Transaction tx = db.beginTx() ) { KernelTransaction ktx = bridge.getKernelTransactionBoundToThisThread( true ); try ( Statement ignore = ktx.acquireStatement() ) { ktx.schemaWrite().indexDrop( index ); } tx.success(); } }
private ResourceIterator<Node> allNodesWithLabel( final Label myLabel ) { KernelTransaction ktx = statementContext.getKernelTransactionBoundToThisThread( true ); Statement statement = ktx.acquireStatement(); int labelId = ktx.tokenRead().nodeLabel( myLabel.name() ); if ( labelId == TokenRead.NO_TOKEN ) { statement.close(); return Iterators.emptyResourceIterator(); } NodeLabelIndexCursor cursor = ktx.cursors().allocateNodeLabelIndexCursor(); ktx.dataRead().nodeLabelScan( labelId, cursor ); return new NodeCursorResourceIterator<>( cursor, statement, this::newNodeProxy ); }
private void assertHasRelationships( long node ) { try ( KernelStatement statement = (KernelStatement) tx.acquireStatement(); StorageNodeCursor nodeCursor = allocateNodeCursor( node ) ) { assertTrue( nodeCursor.next() ); try ( StorageRelationshipTraversalCursor relationships = allocateRelationshipTraversalCursor( nodeCursor ) ) { assertTrue( relationships.next() ); } } }