org.neo4j.kernel.impl.newapi.AllStoreHolder Maven / Gradle / Ivy
/*
* Copyright (c) 2018-2020 "Graph Foundation,"
* Graph Foundation, Inc. [https://graphfoundation.org]
*
* This file is part of ONgDB.
*
* ONgDB 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 customConfiguration )
{
ktx.assertOpen();
return explicitIndexTxState().checkIndexExistence( IndexEntityType.Node, indexName, customConfiguration );
}
@Override
public Map nodeExplicitIndexGetConfiguration( String indexName )
throws ExplicitIndexNotFoundKernelException
{
ktx.assertOpen();
return explicitIndexStore.getNodeIndexConfiguration( indexName );
}
@Override
public String[] relationshipExplicitIndexesGetAll()
{
ktx.assertOpen();
return explicitIndexStore.getAllRelationshipIndexNames();
}
@Override
public boolean relationshipExplicitIndexExists( String indexName, Map customConfiguration )
{
ktx.assertOpen();
return explicitIndexTxState().checkIndexExistence( IndexEntityType.Relationship, indexName, customConfiguration );
}
@Override
public Map relationshipExplicitIndexGetConfiguration( String indexName )
throws ExplicitIndexNotFoundKernelException
{
ktx.assertOpen();
return explicitIndexStore.getRelationshipIndexConfiguration( indexName );
}
@Override
public CapableIndexReference index( int label, int... properties )
{
ktx.assertOpen();
LabelSchemaDescriptor descriptor;
try
{
descriptor = SchemaDescriptorFactory.forLabel( label, properties );
}
catch ( IllegalArgumentException ignore )
{
// This means we have invalid label or property ids.
return CapableIndexReference.NO_INDEX;
}
SchemaIndexDescriptor indexDescriptor = storeReadLayer.indexGetForSchema( descriptor );
if ( ktx.hasTxStateWithChanges() )
{
ReadableDiffSets diffSets =
ktx.txState().indexDiffSetsByLabel( label );
if ( indexDescriptor != null )
{
if ( diffSets.isRemoved( indexDescriptor ) )
{
return CapableIndexReference.NO_INDEX;
}
else
{
return indexGetCapability( indexDescriptor );
}
}
else
{
Iterator fromTxState = filter(
SchemaDescriptor.equalTo( descriptor ),
diffSets.apply( emptyResourceIterator() ) );
if ( fromTxState.hasNext() )
{
return DefaultCapableIndexReference.fromDescriptor( fromTxState.next() );
}
else
{
return CapableIndexReference.NO_INDEX;
}
}
}
return indexDescriptor != null ? indexGetCapability( indexDescriptor ) : CapableIndexReference.NO_INDEX;
}
@Override
public Iterator indexesGetForLabel( int labelId )
{
sharedOptimisticLock( ResourceTypes.LABEL, labelId );
ktx.assertOpen();
Iterator iterator = storeReadLayer.indexesGetForLabel( labelId );
if ( ktx.hasTxStateWithChanges() )
{
iterator = ktx.txState().indexDiffSetsByLabel( labelId ).apply( iterator );
}
return Iterators.map( DefaultIndexReference::fromDescriptor, iterator );
}
@Override
public Iterator indexesGetAll()
{
ktx.assertOpen();
Iterator iterator = storeReadLayer.indexesGetAll();
if ( ktx.hasTxStateWithChanges() )
{
iterator = ktx.txState().indexChanges().apply( storeReadLayer.indexesGetAll() );
}
return Iterators.map( indexDescriptor ->
{
sharedOptimisticLock( ResourceTypes.LABEL, indexDescriptor.schema().keyId() );
return fromDescriptor( indexDescriptor );
}, iterator );
}
@Override
public InternalIndexState indexGetState( IndexReference index ) throws IndexNotFoundKernelException
{
assertValidIndex( index );
sharedOptimisticLock( ResourceTypes.LABEL, index.label() );
ktx.assertOpen();
return indexGetState( indexDescriptor( index ) );
}
@Override
public PopulationProgress indexGetPopulationProgress( IndexReference index )
throws IndexNotFoundKernelException
{
sharedOptimisticLock( ResourceTypes.LABEL, index.label() );
ktx.assertOpen();
SchemaIndexDescriptor descriptor = indexDescriptor( index );
if ( ktx.hasTxStateWithChanges() )
{
if ( checkIndexState( descriptor,
ktx.txState().indexDiffSetsByLabel( index.label() ) ) )
{
return PopulationProgress.NONE;
}
}
return storeReadLayer.indexGetPopulationProgress( descriptor.schema() );
}
@Override
public Long indexGetOwningUniquenessConstraintId( IndexReference index )
{
sharedOptimisticLock( ResourceTypes.LABEL, index.label() );
ktx.assertOpen();
return indexGetOwningUniquenessConstraintId( indexDescriptor( index ) );
}
@Override
public long indexGetCommittedId( IndexReference index ) throws SchemaRuleNotFoundException
{
sharedOptimisticLock( ResourceTypes.LABEL, index.label() );
ktx.assertOpen();
return storeReadLayer.indexGetCommittedId( indexDescriptor( index ) );
}
SchemaIndexDescriptor indexDescriptor( IndexReference index )
{
if ( index.isUnique() )
{
return SchemaIndexDescriptorFactory.uniqueForLabel( index.label(), index.properties() );
}
else
{
return SchemaIndexDescriptorFactory.forLabel( index.label(), index.properties() );
}
}
@Override
public String indexGetFailure( IndexReference index ) throws IndexNotFoundKernelException
{
return storeReadLayer.indexGetFailure( SchemaDescriptorFactory.forLabel( index.label(), index.properties() ) );
}
@Override
public double indexUniqueValuesSelectivity( IndexReference index ) throws IndexNotFoundKernelException
{
acquireSharedLabelLock( index.label() );
ktx.assertOpen();
return storeReadLayer
.indexUniqueValuesPercentage( SchemaDescriptorFactory.forLabel( index.label(), index.properties() ) );
}
@Override
public long indexSize( IndexReference index ) throws IndexNotFoundKernelException
{
acquireSharedLabelLock( index.label() );
ktx.assertOpen();
return storeReadLayer.indexSize( SchemaDescriptorFactory.forLabel( index.label(), index.properties() ) );
}
@Override
public long nodesCountIndexed( IndexReference index, long nodeId, Value value ) throws KernelException
{
ktx.assertOpen();
IndexReader reader = statement.getIndexReader( DefaultIndexReference.toDescriptor( index ) );
return reader.countIndexedNodes( nodeId, value );
}
@Override
public long nodesGetCount( )
{
ktx.assertOpen();
long base = storeReadLayer.nodesGetCount();
return ktx.hasTxStateWithChanges() ? base + ktx.txState().addedAndRemovedNodes().delta() : base;
}
@Override
public long relationshipsGetCount( )
{
ktx.assertOpen();
long base = storeReadLayer.relationshipsGetCount();
return ktx.hasTxStateWithChanges() ? base + ktx.txState().addedAndRemovedRelationships().delta() : base;
}
@Override
public Register.DoubleLongRegister indexUpdatesAndSize( IndexReference index, Register.DoubleLongRegister target )
throws IndexNotFoundKernelException
{
ktx.assertOpen();
return storeReadLayer.indexUpdatesAndSize(
SchemaDescriptorFactory.forLabel( index.label(), index.properties() ), target );
}
@Override
public Register.DoubleLongRegister indexSample( IndexReference index, Register.DoubleLongRegister target )
throws IndexNotFoundKernelException
{
ktx.assertOpen();
return storeReadLayer.indexSample(
SchemaDescriptorFactory.forLabel( index.label(), index.properties() ), target );
}
CapableIndexReference indexGetCapability( SchemaIndexDescriptor schemaIndexDescriptor )
{
try
{
return storeReadLayer.indexReference( schemaIndexDescriptor );
}
catch ( IndexNotFoundKernelException e )
{
throw new IllegalStateException( "Could not find capability for index " + schemaIndexDescriptor, e );
}
}
InternalIndexState indexGetState( SchemaIndexDescriptor descriptor ) throws IndexNotFoundKernelException
{
// If index is in our state, then return populating
if ( ktx.hasTxStateWithChanges() )
{
if ( checkIndexState( descriptor,
ktx.txState().indexDiffSetsByLabel( descriptor.schema().keyId() ) ) )
{
return InternalIndexState.POPULATING;
}
}
return storeReadLayer.indexGetState( descriptor );
}
Long indexGetOwningUniquenessConstraintId( SchemaIndexDescriptor index )
{
return storeReadLayer.indexGetOwningUniquenessConstraintId( index );
}
SchemaIndexDescriptor indexGetForSchema( SchemaDescriptor descriptor )
{
SchemaIndexDescriptor indexDescriptor = storeReadLayer.indexGetForSchema( descriptor );
Iterator rules = iterator( indexDescriptor );
if ( ktx.hasTxStateWithChanges() )
{
rules = filter(
SchemaDescriptor.equalTo( descriptor ),
ktx.txState().indexDiffSetsByLabel( descriptor.keyId() ).apply( rules ) );
}
return singleOrNull( rules );
}
private boolean checkIndexState( SchemaIndexDescriptor index, ReadableDiffSets diffSet )
throws IndexNotFoundKernelException
{
if ( diffSet.isAdded( index ) )
{
return true;
}
if ( diffSet.isRemoved( index ) )
{
throw new IndexNotFoundKernelException( format( "Index on %s has been dropped in this transaction.",
index.userDescription( SchemaUtil.idTokenNameLookup ) ) );
}
return false;
}
@Override
public Iterator constraintsGetForSchema( SchemaDescriptor descriptor )
{
sharedOptimisticLock( descriptor.keyType(), descriptor.keyId() );
ktx.assertOpen();
Iterator constraints = storeReadLayer.constraintsGetForSchema( descriptor );
if ( ktx.hasTxStateWithChanges() )
{
return ktx.txState().constraintsChangesForSchema( descriptor ).apply( constraints );
}
return constraints;
}
@Override
public boolean constraintExists( ConstraintDescriptor descriptor )
{
SchemaDescriptor schema = descriptor.schema();
sharedOptimisticLock( schema.keyType(), schema.keyId() );
ktx.assertOpen();
boolean inStore = storeReadLayer.constraintExists( descriptor );
if ( ktx.hasTxStateWithChanges() )
{
ReadableDiffSets diffSet =
ktx.txState().constraintsChangesForSchema( descriptor.schema() );
return diffSet.isAdded( descriptor ) || (inStore && !diffSet.isRemoved( descriptor ));
}
return inStore;
}
@Override
public Iterator constraintsGetForLabel( int labelId )
{
sharedOptimisticLock( ResourceTypes.LABEL, labelId );
ktx.assertOpen();
Iterator constraints = storeReadLayer.constraintsGetForLabel( labelId );
if ( ktx.hasTxStateWithChanges() )
{
return ktx.txState().constraintsChangesForLabel( labelId ).apply( constraints );
}
return constraints;
}
@Override
public Iterator constraintsGetAll()
{
ktx.assertOpen();
Iterator constraints = storeReadLayer.constraintsGetAll();
if ( ktx.hasTxStateWithChanges() )
{
constraints = ktx.txState().constraintsChanges().apply( constraints );
}
return Iterators.map( this::lockConstraint, constraints );
}
Iterator constraintsGetForProperty( int propertyKey )
{
ktx.assertOpen();
Iterator constraints = storeReadLayer.constraintsGetAll();
if ( ktx.hasTxStateWithChanges() )
{
constraints = ktx.txState().constraintsChanges().apply( constraints );
}
return Iterators.map( this::lockConstraint,
Iterators.filter( hasProperty( propertyKey ), constraints ) );
}
@Override
public Iterator constraintsGetForRelationshipType( int typeId )
{
sharedOptimisticLock( ResourceTypes.RELATIONSHIP_TYPE, typeId );
ktx.assertOpen();
Iterator constraints = storeReadLayer.constraintsGetForRelationshipType( typeId );
if ( ktx.hasTxStateWithChanges() )
{
return ktx.txState().constraintsChangesForRelationshipType( typeId ).apply( constraints );
}
return constraints;
}
@Override
PageCursor nodePage( long reference )
{
return nodes.openPageCursorForReading( reference );
}
@Override
PageCursor relationshipPage( long reference )
{
return relationships.openPageCursorForReading( reference );
}
@Override
PageCursor groupPage( long reference )
{
return groups.openPageCursorForReading( reference );
}
@Override
PageCursor propertyPage( long reference )
{
return properties.openPageCursorForReading( reference );
}
@Override
PageCursor stringPage( long reference )
{
return properties.openStringPageCursor( reference );
}
@Override
PageCursor arrayPage( long reference )
{
return properties.openArrayPageCursor( reference );
}
@Override
RecordCursor labelCursor()
{
return nodes.newLabelCursor();
}
@Override
void node( NodeRecord record, long reference, PageCursor pageCursor )
{
nodes.getRecordByCursor( reference, record, RecordLoad.CHECK, pageCursor );
}
@Override
void relationship( RelationshipRecord record, long reference, PageCursor pageCursor )
{
// When scanning, we inspect RelationshipRecord.inUse(), so using RecordLoad.CHECK is fine
relationships.getRecordByCursor( reference, record, RecordLoad.CHECK, pageCursor );
}
@Override
void relationshipFull( RelationshipRecord record, long reference, PageCursor pageCursor )
{
// We need to load forcefully for relationship chain traversal since otherwise we cannot
// traverse over relationship records which have been concurrently deleted
// (flagged as inUse = false).
// see
// org.neo4j.kernel.impl.store.RelationshipChainPointerChasingTest
// org.neo4j.kernel.impl.locking.RelationshipCreateDeleteIT
relationships.getRecordByCursor( reference, record, RecordLoad.FORCE, pageCursor );
}
@Override
void property( PropertyRecord record, long reference, PageCursor pageCursor )
{
// We need to load forcefully here since otherwise we can have inconsistent reads
// for properties across blocks, see org.neo4j.graphdb.ConsistentPropertyReadsIT
properties.getRecordByCursor( reference, record, RecordLoad.FORCE, pageCursor );
}
@Override
void group( RelationshipGroupRecord record, long reference, PageCursor page )
{
// We need to load forcefully here since otherwise we cannot traverse over groups
// records which have been concurrently deleted (flagged as inUse = false).
// @see #org.neo4j.kernel.impl.store.RelationshipChainPointerChasingTest
groups.getRecordByCursor( reference, record, RecordLoad.FORCE, page );
}
@Override
long nodeHighMark()
{
return nodes.getHighestPossibleIdInUse();
}
@Override
long relationshipHighMark()
{
return relationships.getHighestPossibleIdInUse();
}
@Override
TextValue string( DefaultPropertyCursor cursor, long reference, PageCursor page )
{
ByteBuffer buffer = cursor.buffer = properties.loadString( reference, cursor.buffer, page );
buffer.flip();
return Values.stringValue( UTF8.decode( buffer.array(), 0, buffer.limit() ) );
}
@Override
ArrayValue array( DefaultPropertyCursor cursor, long reference, PageCursor page )
{
ByteBuffer buffer = cursor.buffer = properties.loadArray( reference, cursor.buffer, page );
buffer.flip();
return PropertyUtil.readArrayFromBuffer( buffer );
}
boolean nodeExistsInStore( long id )
{
return storeReadLayer.nodeExists( id );
}
void getOrCreateNodeIndexConfig( String indexName, Map customConfig )
{
explicitIndexStore.getOrCreateNodeIndexConfig( indexName, customConfig );
}
void getOrCreateRelationshipIndexConfig( String indexName, Map customConfig )
{
explicitIndexStore.getOrCreateRelationshipIndexConfig( indexName, customConfig );
}
String indexGetFailure( SchemaIndexDescriptor descriptor ) throws IndexNotFoundKernelException
{
return storeReadLayer.indexGetFailure( descriptor.schema() );
}
@Override
public UserFunctionHandle functionGet( QualifiedName name )
{
ktx.assertOpen();
return procedures.function( name );
}
@Override
public ProcedureHandle procedureGet( QualifiedName name ) throws ProcedureException
{
ktx.assertOpen();
return procedures.procedure( name );
}
@Override
public Set proceduresGetAll( ) throws ProcedureException
{
ktx.assertOpen();
return procedures.getAllProcedures();
}
@Override
public UserFunctionHandle aggregationFunctionGet( QualifiedName name )
{
ktx.assertOpen();
return procedures.aggregationFunction( name );
}
@Override
public RawIterator procedureCallRead( int id, Object[] arguments )
throws ProcedureException
{
AccessMode accessMode = ktx.securityContext().mode();
if ( !accessMode.allowsReads() )
{
throw accessMode.onViolation( format( "Read operations are not allowed for %s.",
ktx.securityContext().description() ) );
}
return callProcedure( id, arguments, new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static
.READ ) );
}
@Override
public RawIterator procedureCallReadOverride( int id, Object[] arguments )
throws ProcedureException
{
return callProcedure( id, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public RawIterator procedureCallWrite( int id, Object[] arguments )
throws ProcedureException
{
AccessMode accessMode = ktx.securityContext().mode();
if ( !accessMode.allowsWrites() )
{
throw accessMode.onViolation( format( "Write operations are not allowed for %s.",
ktx.securityContext().description() ) );
}
return callProcedure( id, arguments,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.TOKEN_WRITE ) );
}
@Override
public RawIterator procedureCallWriteOverride( int id, Object[] arguments )
throws ProcedureException
{
return callProcedure( id, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.TOKEN_WRITE ) );
}
@Override
public RawIterator procedureCallSchema( int id, Object[] arguments )
throws ProcedureException
{
AccessMode accessMode = ktx.securityContext().mode();
if ( !accessMode.allowsSchemaWrites() )
{
throw accessMode.onViolation( format( "Schema operations are not allowed for %s.",
ktx.securityContext().description() ) );
}
return callProcedure( id, arguments,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.FULL ) );
}
@Override
public RawIterator procedureCallSchemaOverride( int id, Object[] arguments )
throws ProcedureException
{
return callProcedure( id, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.FULL ) );
}
@Override
public RawIterator procedureCallRead( QualifiedName name, Object[] arguments )
throws ProcedureException
{
AccessMode accessMode = ktx.securityContext().mode();
if ( !accessMode.allowsReads() )
{
throw accessMode.onViolation( format( "Read operations are not allowed for %s.",
ktx.securityContext().description() ) );
}
return callProcedure( name, arguments, new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static
.READ ) );
}
@Override
public RawIterator procedureCallReadOverride( QualifiedName name, Object[] arguments )
throws ProcedureException
{
return callProcedure( name, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public RawIterator procedureCallWrite( QualifiedName name, Object[] arguments )
throws ProcedureException
{
AccessMode accessMode = ktx.securityContext().mode();
if ( !accessMode.allowsWrites() )
{
throw accessMode.onViolation( format( "Write operations are not allowed for %s.",
ktx.securityContext().description() ) );
}
return callProcedure( name, arguments,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.TOKEN_WRITE ) );
}
@Override
public RawIterator procedureCallWriteOverride( QualifiedName name, Object[] arguments )
throws ProcedureException
{
return callProcedure( name, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.TOKEN_WRITE ) );
}
@Override
public RawIterator procedureCallSchema( QualifiedName name, Object[] arguments )
throws ProcedureException
{
AccessMode accessMode = ktx.securityContext().mode();
if ( !accessMode.allowsSchemaWrites() )
{
throw accessMode.onViolation( format( "Schema operations are not allowed for %s.",
ktx.securityContext().description() ) );
}
return callProcedure( name, arguments,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.FULL ) );
}
@Override
public RawIterator procedureCallSchemaOverride( QualifiedName name,
Object[] arguments )
throws ProcedureException
{
return callProcedure( name, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.FULL ) );
}
@Override
public AnyValue functionCall( int id, AnyValue[] arguments ) throws ProcedureException
{
if ( !ktx.securityContext().mode().allowsReads() )
{
throw ktx.securityContext().mode().onViolation(
format( "Read operations are not allowed for %s.", ktx.securityContext().description() ) );
}
return callFunction( id, arguments,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public AnyValue functionCall( QualifiedName name, AnyValue[] arguments ) throws ProcedureException
{
if ( !ktx.securityContext().mode().allowsReads() )
{
throw ktx.securityContext().mode().onViolation(
format( "Read operations are not allowed for %s.", ktx.securityContext().description() ) );
}
return callFunction( name, arguments,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public AnyValue functionCallOverride( int id, AnyValue[] arguments ) throws ProcedureException
{
return callFunction( id, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public AnyValue functionCallOverride( QualifiedName name, AnyValue[] arguments ) throws ProcedureException
{
return callFunction( name, arguments,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public UserAggregator aggregationFunction( int id ) throws ProcedureException
{
if ( !ktx.securityContext().mode().allowsReads() )
{
throw ktx.securityContext().mode().onViolation(
format( "Read operations are not allowed for %s.", ktx.securityContext().description() ) );
}
return aggregationFunction( id,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public UserAggregator aggregationFunction( QualifiedName name ) throws ProcedureException
{
if ( !ktx.securityContext().mode().allowsReads() )
{
throw ktx.securityContext().mode().onViolation(
format( "Read operations are not allowed for %s.", ktx.securityContext().description() ) );
}
return aggregationFunction( name,
new RestrictedAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public UserAggregator aggregationFunctionOverride( int id ) throws ProcedureException
{
return aggregationFunction( id,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public UserAggregator aggregationFunctionOverride( QualifiedName name ) throws ProcedureException
{
return aggregationFunction( name,
new OverriddenAccessMode( ktx.securityContext().mode(), AccessMode.Static.READ ) );
}
@Override
public ValueMapper © 2015 - 2025 Weber Informatics LLC | Privacy Policy