org.neo4j.kernel.impl.newapi.Read Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-kernel Show documentation
Show all versions of neo4j-kernel Show documentation
Neo4j kernel is a lightweight, embedded Java database designed to
store data structured as graphs rather than tables. For more
information, see http://neo4j.org.
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [http://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see ,
QueryContext
{
protected final StorageReader storageReader;
protected final DefaultPooledCursors cursors;
final KernelTransactionImplementation ktx;
Read( StorageReader storageReader, DefaultPooledCursors cursors, KernelTransactionImplementation ktx )
{
this.storageReader = storageReader;
this.cursors = cursors;
this.ktx = ktx;
}
@Override
public final void nodeIndexSeek( IndexReadSession index, NodeValueIndexCursor cursor, IndexQueryConstraints constraints, PropertyIndexQuery... query )
throws IndexNotApplicableKernelException
{
ktx.assertOpen();
DefaultIndexReadSession indexSession = (DefaultIndexReadSession) index;
if ( indexSession.reference.schema().entityType() != EntityType.NODE )
{
throw new IndexNotApplicableKernelException( "Node index seek can only be performed on node indexes: " +
index.reference().userDescription( ktx.tokenRead() ) );
}
EntityIndexSeekClient client = (EntityIndexSeekClient) cursor;
client.setRead( this );
indexSession.reader.query( this, client, constraints, query );
}
@Override
public final void relationshipIndexSeek( IndexReadSession index, RelationshipValueIndexCursor cursor, IndexQueryConstraints constraints,
PropertyIndexQuery... query ) throws IndexNotApplicableKernelException
{
ktx.assertOpen();
DefaultIndexReadSession indexSession = (DefaultIndexReadSession) index;
if ( indexSession.reference.schema().entityType() != EntityType.RELATIONSHIP )
{
throw new IndexNotApplicableKernelException( "Relationship index seek can only be performed on relationship indexes: " +
index.reference().userDescription( ktx.tokenRead() ) );
}
EntityIndexSeekClient client = (EntityIndexSeekClient) cursor;
client.setRead( this );
indexSession.reader.query( this, client, constraints, query );
}
@Override
public org.neo4j.internal.kernel.api.Read getRead()
{
return this;
}
@Override
public CursorFactory cursors()
{
return cursors;
}
@Override
public ReadableTransactionState getTransactionStateOrNull()
{
return hasTxStateWithChanges() ? txState() : null;
}
@Override
public long lockingNodeUniqueIndexSeek( IndexDescriptor index,
NodeValueIndexCursor cursor,
PropertyIndexQuery.ExactPredicate... predicates )
throws IndexNotApplicableKernelException, IndexNotFoundKernelException, IndexBrokenKernelException
{
assertIndexOnline( index );
assertPredicatesMatchSchema( index, predicates );
Locks.Client locks = ktx.lockClient();
LockTracer lockTracer = ktx.lockTracer();
return LockingNodeUniqueIndexSeek.apply( locks, lockTracer, (DefaultNodeValueIndexCursor)cursor, this, this, index, predicates );
}
@Override // UniqueNodeIndexSeeker
public void nodeIndexSeekWithFreshIndexReader(
DefaultNodeValueIndexCursor cursor,
ValueIndexReader indexReader,
PropertyIndexQuery.ExactPredicate... query ) throws IndexNotApplicableKernelException
{
cursor.setRead( this );
indexReader.query( this, cursor, unconstrained(), query );
}
@Override
public final void nodeIndexScan( IndexReadSession index,
NodeValueIndexCursor cursor,
IndexQueryConstraints constraints ) throws KernelException
{
ktx.assertOpen();
DefaultIndexReadSession indexSession = (DefaultIndexReadSession) index;
if ( indexSession.reference.schema().entityType() != EntityType.NODE )
{
throw new IndexNotApplicableKernelException( "Node index scan can only be performed on node indexes: " +
index.reference().userDescription( ktx.tokenRead() ) );
}
scanIndex( indexSession, (EntityIndexSeekClient) cursor, constraints );
}
@Override
public final void relationshipIndexScan( IndexReadSession index,
RelationshipValueIndexCursor cursor,
IndexQueryConstraints constraints ) throws KernelException
{
ktx.assertOpen();
DefaultIndexReadSession indexSession = (DefaultIndexReadSession) index;
if ( indexSession.reference.schema().entityType() != EntityType.RELATIONSHIP )
{
throw new IndexNotApplicableKernelException( "Relationship index scan can only be performed on relationship indexes: " +
index.reference().userDescription( ktx.tokenRead() ) );
}
scanIndex( indexSession, (EntityIndexSeekClient) cursor, constraints );
}
private void scanIndex( DefaultIndexReadSession indexSession,
EntityIndexSeekClient indexSeekClient,
IndexQueryConstraints constraints ) throws KernelException
{
// for a scan, we simply query for existence of the first property, which covers all entries in an index
int firstProperty = indexSession.reference.schema().getPropertyIds()[0];
indexSeekClient.setRead( this );
indexSession.reader.query( this, indexSeekClient, constraints, PropertyIndexQuery.exists( firstProperty ) );
}
@Override
public final Scan nodeLabelScan( int label )
{
ktx.assertOpen();
CursorContext cursorContext = ktx.cursorContext();
TokenScan tokenScan;
try
{
Iterator index = index( SchemaDescriptor.forAnyEntityTokens( EntityType.NODE ) );
if ( !index.hasNext() )
{
throw new IndexNotFoundKernelException( "There is no index that can back a node label scan." );
}
IndexDescriptor nliDescriptor = index.next();
DefaultTokenReadSession session = (DefaultTokenReadSession) tokenReadSession( nliDescriptor );
tokenScan = session.reader.entityTokenScan( label, cursorContext );
}
catch ( IndexNotFoundKernelException e )
{
throw new RuntimeException( e );
}
return new NodeLabelIndexCursorScan( this, label, tokenScan, cursorContext );
}
@Override
public final void nodeLabelScan( TokenReadSession session, NodeLabelIndexCursor cursor, IndexQueryConstraints constraints, TokenPredicate query )
throws KernelException
{
ktx.assertOpen();
if ( session.reference().schema().entityType() != EntityType.NODE )
{
throw new IndexNotApplicableKernelException( "Node label index scan can not be performed on index " +
session.reference().userDescription( ktx.tokenRead() ) );
}
var tokenSession = (DefaultTokenReadSession) session;
DefaultNodeLabelIndexCursor indexCursor = (DefaultNodeLabelIndexCursor) cursor;
indexCursor.setRead( this );
tokenSession.reader.query( indexCursor, constraints, query, ktx.cursorContext() );
}
@Override
public final void allNodesScan( NodeCursor cursor )
{
ktx.assertOpen();
((DefaultNodeCursor) cursor).scan( this );
}
@Override
public final Scan allNodesScan()
{
ktx.assertOpen();
return new NodeCursorScan( storageReader.allNodeScan(), this, ktx.cursorContext() );
}
@Override
public final void singleNode( long reference, NodeCursor cursor )
{
ktx.assertOpen();
((DefaultNodeCursor) cursor).single( reference, this );
}
@Override
public final void singleRelationship( long reference, RelationshipScanCursor cursor )
{
ktx.assertOpen();
((DefaultRelationshipScanCursor) cursor).single( reference, this );
}
@Override
public final void allRelationshipsScan( RelationshipScanCursor cursor )
{
ktx.assertOpen();
((DefaultRelationshipScanCursor) cursor).scan( this );
}
@Override
public final Scan allRelationshipsScan()
{
ktx.assertOpen();
return new RelationshipCursorScan( storageReader.allRelationshipScan(), this, ktx.cursorContext() );
}
@Override
public final void relationshipTypeScan( TokenReadSession session, RelationshipTypeIndexCursor cursor, IndexQueryConstraints constraints,
TokenPredicate query )
throws KernelException
{
ktx.assertOpen();
if ( session.reference().schema().entityType() != EntityType.RELATIONSHIP )
{
throw new IndexNotApplicableKernelException( "Relationship type index scan can not be performed on index " +
session.reference().userDescription( ktx.tokenRead() ) );
}
var tokenSession = (DefaultTokenReadSession) session;
var indexCursor = (DefaultRelationshipTypeIndexCursor) cursor;
indexCursor.setRead( this );
tokenSession.reader.query( indexCursor, constraints, query, ktx.cursorContext() );
}
@Override
public void relationships( long nodeReference, long reference, RelationshipSelection selection, RelationshipTraversalCursor cursor )
{
((DefaultRelationshipTraversalCursor) cursor).init( nodeReference, reference, selection, this );
}
@Override
public void nodeProperties( long nodeReference, long reference, PropertyCursor cursor )
{
((DefaultPropertyCursor) cursor).initNode( nodeReference, reference, this, ktx );
}
@Override
public void relationshipProperties( long relationshipReference, long reference, PropertyCursor cursor )
{
((DefaultPropertyCursor) cursor).initRelationship( relationshipReference, reference, this, ktx );
}
public abstract ValueIndexReader newValueIndexReader( IndexDescriptor index ) throws IndexNotFoundKernelException;
@Override
public TransactionState txState()
{
return ktx.txState();
}
@Override
public boolean hasTxStateWithChanges()
{
return ktx.hasTxStateWithChanges();
}
@Override
public void acquireExclusiveNodeLock( long... ids )
{
acquireExclusiveLock( ResourceTypes.NODE_RELATIONSHIP_GROUP_DELETE, ids );
acquireExclusiveLock( ResourceTypes.NODE, ids );
ktx.assertOpen();
}
@Override
public void acquireExclusiveRelationshipLock( long... ids )
{
acquireExclusiveLock( ResourceTypes.RELATIONSHIP_DELETE, ids );
acquireExclusiveLock( ResourceTypes.RELATIONSHIP, ids );
ktx.assertOpen();
}
@Override
public void releaseExclusiveNodeLock( long... ids )
{
releaseExclusiveLock( ResourceTypes.NODE, ids );
releaseExclusiveLock( ResourceTypes.NODE_RELATIONSHIP_GROUP_DELETE, ids );
ktx.assertOpen();
}
@Override
public void releaseExclusiveRelationshipLock( long... ids )
{
releaseExclusiveLock( ResourceTypes.RELATIONSHIP, ids );
releaseExclusiveLock( ResourceTypes.RELATIONSHIP_DELETE, ids );
ktx.assertOpen();
}
@Override
public void acquireSharedNodeLock( long... ids )
{
acquireSharedLock( ResourceTypes.NODE_RELATIONSHIP_GROUP_DELETE, ids );
acquireSharedLock( ResourceTypes.NODE, ids );
ktx.assertOpen();
}
@Override
public void acquireSharedRelationshipLock( long... ids )
{
acquireSharedLock( ResourceTypes.RELATIONSHIP_DELETE, ids );
acquireSharedLock( ResourceTypes.RELATIONSHIP, ids );
ktx.assertOpen();
}
@Override
public void acquireSharedRelationshipTypeLock( long... ids )
{
acquireSharedLock( ResourceTypes.RELATIONSHIP_TYPE, ids );
ktx.assertOpen();
}
@Override
public void acquireSharedLabelLock( long... ids )
{
acquireSharedLock( ResourceTypes.LABEL, ids );
ktx.assertOpen();
}
@Override
public void releaseSharedNodeLock( long... ids )
{
releaseSharedLock( ResourceTypes.NODE, ids );
releaseSharedLock( ResourceTypes.NODE_RELATIONSHIP_GROUP_DELETE, ids );
ktx.assertOpen();
}
@Override
public void releaseSharedRelationshipLock( long... ids )
{
releaseSharedLock( ResourceTypes.RELATIONSHIP, ids );
releaseSharedLock( ResourceTypes.RELATIONSHIP_DELETE, ids );
ktx.assertOpen();
}
@Override
public void releaseSharedLabelLock( long... ids )
{
releaseSharedLock( ResourceTypes.LABEL, ids );
ktx.assertOpen();
}
@Override
public void releaseSharedRelationshipTypeLock( long... ids )
{
releaseSharedLock( ResourceTypes.RELATIONSHIP_TYPE, ids );
ktx.assertOpen();
}
T acquireSharedSchemaLock( T schemaLike )
{
SchemaDescriptor schema = schemaLike.schema();
long[] lockingKeys = schema.lockingKeys();
ktx.lockClient().acquireShared( ktx.lockTracer(), schema.keyType(), lockingKeys );
return schemaLike;
}
void releaseSharedSchemaLock( T schemaLike )
{
SchemaDescriptor schema = schemaLike.schema();
long[] lockingKeys = schema.lockingKeys();
ktx.lockClient().releaseShared( schema.keyType(), lockingKeys );
}
void acquireSharedLock( ResourceType resource, long resourceId )
{
ktx.lockClient().acquireShared( ktx.lockTracer(), resource, resourceId );
}
private void acquireExclusiveLock( ResourceTypes types, long... ids )
{
ktx.lockClient().acquireExclusive( ktx.lockTracer(), types, ids );
}
private void releaseExclusiveLock( ResourceTypes types, long... ids )
{
ktx.lockClient().releaseExclusive( types, ids );
}
private void acquireSharedLock( ResourceTypes types, long... ids )
{
ktx.lockClient().acquireShared( ktx.lockTracer(), types, ids );
}
private void releaseSharedLock( ResourceTypes types, long... ids )
{
ktx.lockClient().releaseShared( types, ids );
}
private void assertIndexOnline( IndexDescriptor index )
throws IndexNotFoundKernelException, IndexBrokenKernelException
{
if ( indexGetState( index ) == InternalIndexState.ONLINE )
{
return;
}
throw new IndexBrokenKernelException( indexGetFailure( index ) );
}
private static void assertPredicatesMatchSchema( IndexDescriptor index, PropertyIndexQuery.ExactPredicate[] predicates )
throws IndexNotApplicableKernelException
{
int[] propertyIds = index.schema().getPropertyIds();
if ( propertyIds.length != predicates.length )
{
throw new IndexNotApplicableKernelException(
format( "The index specifies %d properties, but only %d lookup predicates were given.",
propertyIds.length, predicates.length ) );
}
for ( int i = 0; i < predicates.length; i++ )
{
if ( predicates[i].propertyKeyId() != propertyIds[i] )
{
throw new IndexNotApplicableKernelException(
format( "The index has the property id %d in position %d, but the lookup property id was %d.",
propertyIds[i], i, predicates[i].propertyKeyId() ) );
}
}
}
@Override
public void assertOpen()
{
ktx.assertOpen();
}
@Override
public void acquireSharedLookupLock( EntityType entityType )
{
acquireSharedSchemaLock( SchemaDescriptor.forAnyEntityTokens( entityType ) );
ktx.assertOpen();
}
@Override
public void releaseSharedLookupLock( EntityType entityType )
{
releaseSharedSchemaLock( SchemaDescriptor.forAnyEntityTokens( entityType ) );
ktx.assertOpen();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy