Unnamed: 0
int64 0
6.7k
| func
stringlengths 12
89.6k
| target
bool 2
classes | project
stringlengths 45
151
|
|---|---|---|---|
4,100
|
public class ExecutionOrderIntegrationTest
{
@Rule
public final GraphStoreFixture fixture = new GraphStoreFixture()
{
@Override
protected void generateInitialData( GraphDatabaseService graphDb )
{
// TODO: create bigger sample graph here
try ( org.neo4j.graphdb.Transaction tx = graphDb.beginTx() )
{
Node node1 = set( graphDb.createNode() );
Node node2 = set( graphDb.createNode(), property( "key", "value" ) );
node1.createRelationshipTo( node2, DynamicRelationshipType.withName( "C" ) );
tx.success();
}
}
};
private static final boolean LOG_DUPLICATES = false;
@Test
public void shouldRunSameChecksInMultiPassAsInSingleSingleThreadedPass() throws Exception
{
// given
StoreAccess store = fixture.directStoreAccess().nativeStores();
DiffRecordAccess access = FullCheck.recordAccess( store );
FullCheck singlePass = new FullCheck( config( TaskExecutionOrder.SINGLE_THREADED ),
ProgressMonitorFactory.NONE );
FullCheck multiPass = new FullCheck( config( TaskExecutionOrder.MULTI_PASS ),
ProgressMonitorFactory.NONE );
ConsistencySummaryStatistics multiPassSummary = new ConsistencySummaryStatistics();
ConsistencySummaryStatistics singlePassSummary = new ConsistencySummaryStatistics();
InconsistencyLogger logger = mock( InconsistencyLogger.class );
InvocationLog singlePassChecks = new InvocationLog();
InvocationLog multiPassChecks = new InvocationLog();
// when
singlePass.execute( fixture.directStoreAccess(), new LogDecorator( singlePassChecks ), access, new InconsistencyReport( logger,
singlePassSummary ) );
multiPass.execute( fixture.directStoreAccess(), new LogDecorator( multiPassChecks ), access, new InconsistencyReport( logger,
multiPassSummary ) );
// then
verifyZeroInteractions( logger );
assertEquals( "Expected no inconsistencies in single pass.",
0, singlePassSummary.getTotalInconsistencyCount() );
assertEquals( "Expected no inconsistencies in multiple passes.",
0, multiPassSummary.getTotalInconsistencyCount() );
assertSameChecks( singlePassChecks.data, multiPassChecks.data );
if ( singlePassChecks.duplicates.size() != multiPassChecks.duplicates.size() )
{
if ( LOG_DUPLICATES )
{
System.out.printf( "Duplicate checks with single pass: %s, duplicate checks with multiple passes: %s%n",
singlePassChecks.duplicates, multiPassChecks.duplicates );
}
}
}
static Config config( TaskExecutionOrder executionOrder )
{
return new Config( stringMap(
ConsistencyCheckSettings.consistency_check_execution_order.name(), executionOrder.name() ),
GraphDatabaseSettings.class, ConsistencyCheckSettings.class );
}
private static class InvocationLog
{
private final Map<String, Throwable> data = new HashMap<>();
private final Map<String, Integer> duplicates = new HashMap<>();
@SuppressWarnings("ThrowableResultOfMethodCallIgnored")
void log( PendingReferenceCheck check, InvocationOnMock invocation )
{
Method method = invocation.getMethod();
if ( Object.class == method.getDeclaringClass() && "finalize".equals( method.getName() ) )
{
/* skip invocations to finalize - they are not of interest to us,
* and GC is not predictable enough to reliably trace this. */
return;
}
StringBuilder entry = new StringBuilder( method.getName() ).append( '(' );
entry.append( check );
for ( Object arg : invocation.getArguments() )
{
if ( arg instanceof AbstractBaseRecord )
{
AbstractBaseRecord record = (AbstractBaseRecord) arg;
entry.append( ',' ).append( record.getClass().getSimpleName() )
.append( '[' ).append( record.getLongId() ).append( ']' );
}
}
String message = entry.append( ')' ).toString();
if ( null != data.put( message, new Throwable( message ) ) )
{
Integer cur = duplicates.get( message );
if ( cur == null )
{
cur = 1;
}
duplicates.put( message, cur + 1 );
}
}
}
private static void assertSameChecks( Map<String, Throwable> singlePassChecks,
Map<String, Throwable> multiPassChecks )
{
if ( !singlePassChecks.keySet().equals( multiPassChecks.keySet() ) )
{
Map<String, Throwable> missing = new HashMap<>( singlePassChecks );
Map<String, Throwable> extras = new HashMap<>( multiPassChecks );
missing.keySet().removeAll( multiPassChecks.keySet() );
extras.keySet().removeAll( singlePassChecks.keySet() );
StringBuilder headers = new StringBuilder("\n");
StringWriter diff = new StringWriter();
PrintWriter writer = new PrintWriter( diff );
if ( !missing.isEmpty() )
{
writer.append( "These expected checks were missing:\n" );
for ( Map.Entry<String, Throwable> check : missing.entrySet() )
{
writer.append( " " );
headers.append( "Missing: " ).append( check.getKey() ).append( "\n" );
check.getValue().printStackTrace( writer );
}
}
if ( !extras.isEmpty() )
{
writer.append( "These extra checks were not expected:\n" );
for ( Map.Entry<String, Throwable> check : extras.entrySet() )
{
writer.append( " " );
headers.append( "Unexpected: " ).append( check.getKey() ).append( "\n" );
check.getValue().printStackTrace( writer );
}
}
fail( headers.toString() + diff.toString() );
}
}
private static class LogDecorator implements CheckDecorator
{
private final InvocationLog log;
LogDecorator( InvocationLog log )
{
this.log = log;
}
<REC extends AbstractBaseRecord, REP extends ConsistencyReport> RecordCheck<REC, REP> logging(
RecordCheck<REC, REP> checker )
{
return new LoggingChecker<>( checker, log );
}
@Override
public RecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> decorateNeoStoreChecker(
PrimitiveRecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> checker )
{
return logging( checker );
}
@Override
public RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> decorateNodeChecker(
PrimitiveRecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> checker )
{
return logging( checker );
}
@Override
public RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport>
decorateRelationshipChecker(
PrimitiveRecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> checker )
{
return logging( checker );
}
@Override
public RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> decoratePropertyChecker(
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> checker )
{
return logging( checker );
}
@Override
public RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport>
decoratePropertyKeyTokenChecker(
RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> checker )
{
return logging( checker );
}
@Override
public RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> decorateRelationshipTypeTokenChecker(
RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> checker )
{
return logging( checker );
}
@Override
public RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport> decorateLabelTokenChecker(
RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport> checker )
{
return logging( checker );
}
@Override
public RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> decorateLabelMatchChecker(
RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> checker )
{
return logging( checker );
}
}
private static class LoggingChecker<REC extends AbstractBaseRecord, REP extends ConsistencyReport>
implements RecordCheck<REC, REP>
{
private final RecordCheck<REC, REP> checker;
private final InvocationLog log;
LoggingChecker( RecordCheck<REC, REP> checker, InvocationLog log )
{
this.checker = checker;
this.log = log;
}
@Override
public void check( REC record, CheckerEngine<REC, REP> engine, RecordAccess records )
{
checker.check( record, engine, new ComparativeLogging( (DiffRecordAccess) records, log ) );
}
@Override
public void checkChange( REC oldRecord, REC newRecord, CheckerEngine<REC, REP> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, new ComparativeLogging( records, log ) );
}
}
private static class LoggingReference<T extends AbstractBaseRecord> implements RecordReference<T>
{
private final RecordReference<T> reference;
private final InvocationLog log;
LoggingReference( RecordReference<T> reference, InvocationLog log )
{
this.reference = reference;
this.log = log;
}
@SuppressWarnings("unchecked")
@Override
public void dispatch( PendingReferenceCheck<T> reporter )
{
reference.dispatch( mock( (Class<PendingReferenceCheck<T>>) reporter.getClass(),
withSettings().spiedInstance( reporter )
.defaultAnswer( new ReporterSpy<>( reference, reporter, log ) ) ) );
}
}
private static class ReporterSpy<T extends AbstractBaseRecord> implements Answer<Object>
{
private final RecordReference<T> reference;
private final PendingReferenceCheck<T> reporter;
private final InvocationLog log;
public ReporterSpy( RecordReference<T> reference, PendingReferenceCheck<T> reporter, InvocationLog log )
{
this.reference = reference;
this.reporter = reporter;
this.log = log;
}
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
if ( !(reference instanceof RecordReference.SkippingReference<?>) )
{
log.log( reporter, invocation );
}
return invocation.callRealMethod();
}
}
private static class ComparativeLogging implements DiffRecordAccess
{
private final DiffRecordAccess access;
private final InvocationLog log;
ComparativeLogging( DiffRecordAccess access, InvocationLog log )
{
this.access = access;
this.log = log;
}
private <T extends AbstractBaseRecord> LoggingReference<T> logging( RecordReference<T> actual )
{
return new LoggingReference<>( actual, log );
}
@Override
public RecordReference<NodeRecord> previousNode( long id )
{
return logging( access.previousNode( id ) );
}
@Override
public RecordReference<RelationshipRecord> previousRelationship( long id )
{
return logging( access.previousRelationship( id ) );
}
@Override
public RecordReference<PropertyRecord> previousProperty( long id )
{
return logging( access.previousProperty( id ) );
}
@Override
public RecordReference<NeoStoreRecord> previousGraph()
{
return logging( access.previousGraph() );
}
@Override
public DynamicRecord changedSchema( long id )
{
return access.changedSchema( id );
}
@Override
public NodeRecord changedNode( long id )
{
return access.changedNode( id );
}
@Override
public RelationshipRecord changedRelationship( long id )
{
return access.changedRelationship( id );
}
@Override
public PropertyRecord changedProperty( long id )
{
return access.changedProperty( id );
}
@Override
public DynamicRecord changedString( long id )
{
return access.changedString( id );
}
@Override
public DynamicRecord changedArray( long id )
{
return access.changedArray( id );
}
@Override
public RecordReference<DynamicRecord> schema( long id )
{
return logging( access.schema( id ) );
}
@Override
public RecordReference<NodeRecord> node( long id )
{
return logging( access.node( id ) );
}
@Override
public RecordReference<RelationshipRecord> relationship( long id )
{
return logging( access.relationship( id ) );
}
@Override
public RecordReference<PropertyRecord> property( long id )
{
return logging( access.property( id ) );
}
@Override
public RecordReference<RelationshipTypeTokenRecord> relationshipType( int id )
{
return logging( access.relationshipType( id ) );
}
@Override
public RecordReference<PropertyKeyTokenRecord> propertyKey( int id )
{
return logging( access.propertyKey( id ) );
}
@Override
public RecordReference<DynamicRecord> string( long id )
{
return logging( access.string( id ) );
}
@Override
public RecordReference<DynamicRecord> array( long id )
{
return logging( access.array( id ) );
}
@Override
public RecordReference<DynamicRecord> relationshipTypeName( int id )
{
return logging( access.relationshipTypeName( id ) );
}
@Override
public RecordReference<DynamicRecord> nodeLabels( long id )
{
return logging( access.nodeLabels( id ) );
}
@Override
public RecordReference<LabelTokenRecord> label( int id )
{
return logging( access.label( id ) );
}
@Override
public RecordReference<DynamicRecord> labelName( int id )
{
return logging( access.labelName( id ) );
}
@Override
public RecordReference<DynamicRecord> propertyKeyName( int id )
{
return logging( access.propertyKeyName( id ) );
}
@Override
public RecordReference<NeoStoreRecord> graph()
{
return logging( access.graph() );
}
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_ExecutionOrderIntegrationTest.java
|
4,101
|
static class Unknown extends DynamicOwner<AbstractBaseRecord> implements RecordReference<AbstractBaseRecord>
{
private PendingReferenceCheck<AbstractBaseRecord> reporter;
@Override
RecordReference<AbstractBaseRecord> record( RecordAccess records )
{
// Getting the record for this owner means that some other owner replaced it
// that means that it isn't an orphan, so we skip this orphan check
// and return a record for conflict check that always is ok (by skipping the check)
this.markInCustody();
return skipReference();
}
public void checkOrphanage()
{
PendingReferenceCheck<AbstractBaseRecord> reporter = pop();
if ( reporter != null )
{
reporter.checkReference( null, null );
}
}
void markInCustody()
{
PendingReferenceCheck<AbstractBaseRecord> reporter = pop();
if ( reporter != null )
{
reporter.skip();
}
}
private synchronized PendingReferenceCheck<AbstractBaseRecord> pop()
{
try
{
return this.reporter;
}
finally
{
this.reporter = null;
}
}
@Override
public synchronized void dispatch( PendingReferenceCheck<AbstractBaseRecord> reporter )
{
this.reporter = reporter;
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,102
|
static class RelationshipTypeToken extends NameOwner<RelationshipTypeTokenRecord,ConsistencyReport.RelationshipTypeConsistencyReport>
{
private final int id;
RelationshipTypeToken( RelationshipTypeTokenRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<RelationshipTypeTokenRecord> record( RecordAccess records )
{
return records.relationshipType( id );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,103
|
static class PropertyKey extends NameOwner<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport>
{
private final int id;
PropertyKey( PropertyKeyTokenRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<PropertyKeyTokenRecord> record( RecordAccess records )
{
return records.propertyKey( id );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,104
|
static class Property extends DynamicOwner<PropertyRecord>
implements ComparativeRecordChecker<PropertyRecord, AbstractBaseRecord, ConsistencyReport.PropertyConsistencyReport>
{
private final long id;
private final RecordType type;
Property( RecordType type, PropertyRecord record )
{
this.type = type;
this.id = record.getId();
}
@Override
RecordReference<PropertyRecord> record( RecordAccess records )
{
return records.property( id );
}
@Override
public void checkReference( PropertyRecord property, AbstractBaseRecord record,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( record instanceof PropertyRecord )
{
if ( type == RecordType.STRING_PROPERTY )
{
engine.report().stringMultipleOwners( (PropertyRecord) record );
}
else
{
engine.report().arrayMultipleOwners( (PropertyRecord) record );
}
}
else if ( record instanceof DynamicRecord )
{
if ( type == RecordType.STRING_PROPERTY )
{
engine.report().stringMultipleOwners( (DynamicRecord) record );
}
else
{
engine.report().arrayMultipleOwners( (DynamicRecord) record );
}
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,105
|
static abstract class NameOwner<RECORD extends TokenRecord, REPORT extends ConsistencyReport.NameConsistencyReport> extends DynamicOwner<RECORD>
implements ComparativeRecordChecker<RECORD, AbstractBaseRecord, REPORT>
{
@SuppressWarnings("ConstantConditions")
@Override
public void checkReference( RECORD name, AbstractBaseRecord record, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
ConsistencyReport.NameConsistencyReport report = engine.report();
if ( record instanceof RelationshipTypeTokenRecord )
{
((ConsistencyReport.RelationshipTypeConsistencyReport) report)
.nameMultipleOwners( (RelationshipTypeTokenRecord) record );
}
else if ( record instanceof PropertyKeyTokenRecord )
{
((ConsistencyReport.PropertyKeyTokenConsistencyReport) report)
.nameMultipleOwners( (PropertyKeyTokenRecord) record );
}
else if ( record instanceof DynamicRecord )
{
report.nameMultipleOwners( (DynamicRecord) record );
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,106
|
static class LabelToken extends NameOwner<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport>
{
private final int id;
LabelToken( LabelTokenRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<LabelTokenRecord> record( RecordAccess records )
{
return records.label( id );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,107
|
static class Dynamic extends DynamicOwner<DynamicRecord>
implements ComparativeRecordChecker<DynamicRecord, AbstractBaseRecord, ConsistencyReport.DynamicConsistencyReport>
{
private final long id;
private final RecordType type;
Dynamic( RecordType type, DynamicRecord record )
{
this.type = type;
this.id = record.getId();
}
@Override
RecordReference<DynamicRecord> record( RecordAccess records )
{
switch ( type )
{
case STRING_PROPERTY:
return records.string( id );
case ARRAY_PROPERTY:
return records.array( id );
case PROPERTY_KEY_NAME:
return records.propertyKeyName( (int)id );
case RELATIONSHIP_TYPE_NAME:
return records.relationshipTypeName( (int) id );
default:
return skipReference();
}
}
@Override
public void checkReference( DynamicRecord block, AbstractBaseRecord record,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
RecordAccess records )
{
if ( record instanceof PropertyRecord )
{
engine.report().nextMultipleOwners( (PropertyRecord) record );
}
else if ( record instanceof DynamicRecord )
{
engine.report().nextMultipleOwners( (DynamicRecord) record );
}
else if ( record instanceof RelationshipTypeTokenRecord )
{
engine.report().nextMultipleOwners( (RelationshipTypeTokenRecord) record );
}
else if ( record instanceof PropertyKeyTokenRecord )
{
engine.report().nextMultipleOwners( (PropertyKeyTokenRecord) record );
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,108
|
{
@Override
public void checkReference( DynamicRecord record, AbstractBaseRecord ignored,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
RecordAccess records )
{
engine.report().orphanDynamicRecord();
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,109
|
abstract class DynamicOwner<RECORD extends AbstractBaseRecord> implements Owner
{
static final ComparativeRecordChecker<DynamicRecord, AbstractBaseRecord, ConsistencyReport.DynamicConsistencyReport>
ORPHAN_CHECK =
new ComparativeRecordChecker<DynamicRecord, AbstractBaseRecord, ConsistencyReport.DynamicConsistencyReport>()
{
@Override
public void checkReference( DynamicRecord record, AbstractBaseRecord ignored,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
RecordAccess records )
{
engine.report().orphanDynamicRecord();
}
};
abstract RecordReference<RECORD> record( RecordAccess records );
@Override
public void checkOrphanage()
{
// default: do nothing
}
static class Property extends DynamicOwner<PropertyRecord>
implements ComparativeRecordChecker<PropertyRecord, AbstractBaseRecord, ConsistencyReport.PropertyConsistencyReport>
{
private final long id;
private final RecordType type;
Property( RecordType type, PropertyRecord record )
{
this.type = type;
this.id = record.getId();
}
@Override
RecordReference<PropertyRecord> record( RecordAccess records )
{
return records.property( id );
}
@Override
public void checkReference( PropertyRecord property, AbstractBaseRecord record,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( record instanceof PropertyRecord )
{
if ( type == RecordType.STRING_PROPERTY )
{
engine.report().stringMultipleOwners( (PropertyRecord) record );
}
else
{
engine.report().arrayMultipleOwners( (PropertyRecord) record );
}
}
else if ( record instanceof DynamicRecord )
{
if ( type == RecordType.STRING_PROPERTY )
{
engine.report().stringMultipleOwners( (DynamicRecord) record );
}
else
{
engine.report().arrayMultipleOwners( (DynamicRecord) record );
}
}
}
}
static class Dynamic extends DynamicOwner<DynamicRecord>
implements ComparativeRecordChecker<DynamicRecord, AbstractBaseRecord, ConsistencyReport.DynamicConsistencyReport>
{
private final long id;
private final RecordType type;
Dynamic( RecordType type, DynamicRecord record )
{
this.type = type;
this.id = record.getId();
}
@Override
RecordReference<DynamicRecord> record( RecordAccess records )
{
switch ( type )
{
case STRING_PROPERTY:
return records.string( id );
case ARRAY_PROPERTY:
return records.array( id );
case PROPERTY_KEY_NAME:
return records.propertyKeyName( (int)id );
case RELATIONSHIP_TYPE_NAME:
return records.relationshipTypeName( (int) id );
default:
return skipReference();
}
}
@Override
public void checkReference( DynamicRecord block, AbstractBaseRecord record,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
RecordAccess records )
{
if ( record instanceof PropertyRecord )
{
engine.report().nextMultipleOwners( (PropertyRecord) record );
}
else if ( record instanceof DynamicRecord )
{
engine.report().nextMultipleOwners( (DynamicRecord) record );
}
else if ( record instanceof RelationshipTypeTokenRecord )
{
engine.report().nextMultipleOwners( (RelationshipTypeTokenRecord) record );
}
else if ( record instanceof PropertyKeyTokenRecord )
{
engine.report().nextMultipleOwners( (PropertyKeyTokenRecord) record );
}
}
}
static abstract class NameOwner<RECORD extends TokenRecord, REPORT extends ConsistencyReport.NameConsistencyReport> extends DynamicOwner<RECORD>
implements ComparativeRecordChecker<RECORD, AbstractBaseRecord, REPORT>
{
@SuppressWarnings("ConstantConditions")
@Override
public void checkReference( RECORD name, AbstractBaseRecord record, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
ConsistencyReport.NameConsistencyReport report = engine.report();
if ( record instanceof RelationshipTypeTokenRecord )
{
((ConsistencyReport.RelationshipTypeConsistencyReport) report)
.nameMultipleOwners( (RelationshipTypeTokenRecord) record );
}
else if ( record instanceof PropertyKeyTokenRecord )
{
((ConsistencyReport.PropertyKeyTokenConsistencyReport) report)
.nameMultipleOwners( (PropertyKeyTokenRecord) record );
}
else if ( record instanceof DynamicRecord )
{
report.nameMultipleOwners( (DynamicRecord) record );
}
}
}
static class PropertyKey extends NameOwner<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport>
{
private final int id;
PropertyKey( PropertyKeyTokenRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<PropertyKeyTokenRecord> record( RecordAccess records )
{
return records.propertyKey( id );
}
}
static class LabelToken extends NameOwner<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport>
{
private final int id;
LabelToken( LabelTokenRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<LabelTokenRecord> record( RecordAccess records )
{
return records.label( id );
}
}
static class RelationshipTypeToken extends NameOwner<RelationshipTypeTokenRecord,ConsistencyReport.RelationshipTypeConsistencyReport>
{
private final int id;
RelationshipTypeToken( RelationshipTypeTokenRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<RelationshipTypeTokenRecord> record( RecordAccess records )
{
return records.relationshipType( id );
}
}
static class Unknown extends DynamicOwner<AbstractBaseRecord> implements RecordReference<AbstractBaseRecord>
{
private PendingReferenceCheck<AbstractBaseRecord> reporter;
@Override
RecordReference<AbstractBaseRecord> record( RecordAccess records )
{
// Getting the record for this owner means that some other owner replaced it
// that means that it isn't an orphan, so we skip this orphan check
// and return a record for conflict check that always is ok (by skipping the check)
this.markInCustody();
return skipReference();
}
public void checkOrphanage()
{
PendingReferenceCheck<AbstractBaseRecord> reporter = pop();
if ( reporter != null )
{
reporter.checkReference( null, null );
}
}
void markInCustody()
{
PendingReferenceCheck<AbstractBaseRecord> reporter = pop();
if ( reporter != null )
{
reporter.skip();
}
}
private synchronized PendingReferenceCheck<AbstractBaseRecord> pop()
{
try
{
return this.reporter;
}
finally
{
this.reporter = null;
}
}
@Override
public synchronized void dispatch( PendingReferenceCheck<AbstractBaseRecord> reporter )
{
this.reporter = reporter;
}
}
private DynamicOwner()
{
// only internal subclasses
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_DynamicOwner.java
|
4,110
|
public class ConsistencyCheckTasks
{
private final ProgressMonitorFactory.MultiPartBuilder progress;
private final TaskExecutionOrder order;
private final StoreProcessor processor;
ConsistencyCheckTasks( ProgressMonitorFactory.MultiPartBuilder progress, TaskExecutionOrder order,
StoreProcessor processor )
{
this.progress = progress;
this.order = order;
this.processor = processor;
}
public List<StoppableRunnable> createTasks(
StoreAccess nativeStores, LabelScanStore labelScanStore, IndexAccessors indexes,
MultiPassStore.Factory multiPass, ConsistencyReporter reporter,
boolean checkLabelScanStore, boolean checkIndexes )
{
List<StoppableRunnable> tasks = new ArrayList<>();
tasks.add( create( nativeStores.getNodeStore(),
multiPass.processors( PROPERTIES, RELATIONSHIPS ) ) );
tasks.add( create( nativeStores.getRelationshipStore(),
multiPass.processors( NODES, PROPERTIES, RELATIONSHIPS ) ) );
tasks.add( create( nativeStores.getPropertyStore(),
multiPass.processors( PROPERTIES, STRINGS, ARRAYS ) ) );
tasks.add( create( nativeStores.getStringStore(), multiPass.processors( STRINGS ) ) );
tasks.add( create( nativeStores.getArrayStore(), multiPass.processors( ARRAYS ) ) );
// The schema store is verified in multiple passes that share state since it fits into memory
// and we care about the consistency of back references (cf. SemanticCheck)
// PASS 1: Dynamic record chains
tasks.add( create( nativeStores.getSchemaStore() ));
// PASS 2: Rule integrity and obligation build up
final SchemaRecordCheck schemaCheck = new SchemaRecordCheck( new SchemaStorage( nativeStores.getSchemaStore() ) );
tasks.add( new SchemaStoreProcessorTask<>(
nativeStores.getSchemaStore(), "check_rules", schemaCheck, progress, order,
processor, processor ) );
// PASS 3: Obligation verification and semantic rule uniqueness
tasks.add( new SchemaStoreProcessorTask<>(
nativeStores.getSchemaStore(), "check_obligations", schemaCheck.forObligationChecking(), progress, order,
processor, processor ) );
tasks.add( create( nativeStores.getRelationshipTypeTokenStore() ) );
tasks.add( create( nativeStores.getPropertyKeyTokenStore() ) );
tasks.add( create( nativeStores.getLabelTokenStore() ) );
tasks.add( create( nativeStores.getRelationshipTypeNameStore() ) );
tasks.add( create( nativeStores.getPropertyKeyNameStore() ) );
tasks.add( create( nativeStores.getLabelNameStore() ) );
tasks.add( create( nativeStores.getNodeDynamicLabelStore() ) );
if ( checkLabelScanStore )
{
tasks.add( new RecordScanner<>( new IterableStore<>( nativeStores.getNodeStore() ),
"NodeStoreToLabelScanStore",
progress, new NodeToLabelScanRecordProcessor( reporter, labelScanStore ) ) );
}
if ( checkIndexes )
{
tasks.add( new RecordScanner<>( new IterableStore<>( nativeStores.getNodeStore() ), "NodeStoreToIndexes",
progress, new NodeToLabelIndexesProcessor( reporter, indexes,
new PropertyReader( (PropertyStore) nativeStores.getPropertyStore() ) ) ) );
}
int iPass = 0;
for ( ConsistencyReporter filteredReporter : multiPass.reporters( order, NODES ) )
{
if ( checkLabelScanStore )
{
tasks.add( new RecordScanner<>( labelScanStore.newAllEntriesReader(),
format( "LabelScanStore_%d", iPass ), progress, new LabelScanDocumentProcessor(
filteredReporter,
new LabelScanCheck() ) ) );
}
if ( checkIndexes )
{
for ( IndexRule indexRule : indexes.rules() )
{
tasks.add( new RecordScanner<>( new IndexIterator( indexes.accessorFor( indexRule ) ),
format( "Index_%d_%d", indexRule.getId(), iPass ), progress,
new IndexEntryProcessor( filteredReporter,
new IndexCheck( indexRule ) ) ) );
}
}
iPass++;
}
return tasks;
}
<RECORD extends AbstractBaseRecord> StoreProcessorTask<RECORD> create( RecordStore<RECORD> input )
{
return new StoreProcessorTask<>(
input, progress, order, processor, processor );
}
<RECORD extends AbstractBaseRecord> StoreProcessorTask<RECORD> create( RecordStore<RECORD> input,
StoreProcessor[] processors )
{
return new StoreProcessorTask<>(
input, progress, order, processor, processors );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_ConsistencyCheckTasks.java
|
4,111
|
public class ConsistencyCheckIncompleteException extends Exception
{
public ConsistencyCheckIncompleteException( Exception cause )
{
super( "Full consistency check did not complete", cause );
}
@Override
public void printStackTrace( PrintStream s )
{
super.printStackTrace( s );
printMultiCause( getCause(), new PrintWriter( s, true ) );
}
@Override
public void printStackTrace( PrintWriter s )
{
super.printStackTrace( s );
printMultiCause( getCause(), s );
}
private static void printMultiCause( Throwable cause, PrintWriter writer )
{
if ( cause instanceof ProcessFailureException )
{
((ProcessFailureException) cause).printAllCauses( writer );
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_ConsistencyCheckIncompleteException.java
|
4,112
|
abstract class TokenRecordCheck<RECORD extends TokenRecord, REPORT extends ConsistencyReport>
implements RecordCheck<RECORD, REPORT>, ComparativeRecordChecker<RECORD, DynamicRecord, REPORT>
{
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
check( newRecord, engine, records );
}
@Override
public void check( RECORD record, CheckerEngine<RECORD, REPORT> engine, RecordAccess records )
{
if ( !record.inUse() )
{
return;
}
if ( !Record.NO_NEXT_BLOCK.is( record.getNameId() ) )
{
engine.comparativeCheck( name( records, record.getNameId() ), this );
}
}
@Override
public void checkReference( RECORD record, DynamicRecord name, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
if ( !name.inUse() )
{
nameNotInUse( engine.report(), name );
}
else
{
if ( name.getLength() <= 0 )
{
emptyName( engine.report(), name );
}
}
}
abstract RecordReference<DynamicRecord> name( RecordAccess records, int id );
abstract void nameNotInUse( REPORT report, DynamicRecord name );
abstract void emptyName( REPORT report, DynamicRecord name );
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_TokenRecordCheck.java
|
4,113
|
public class SchemaRuleContentTest
{
@Test
public void shouldReportIndexRulesWithSameLabelAndPropertyAsEqual() throws Exception
{
// given
SchemaIndexProvider.Descriptor descriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
SchemaRuleContent rule1 = new SchemaRuleContent( indexRule( 0, 1, 2, descriptor ) );
SchemaRuleContent rule2 = new SchemaRuleContent( indexRule( 1, 1, 2, descriptor ) );
// then
assertReflectivelyEquals( rule1, rule2 );
}
@Test
public void shouldReportConstraintIndexRulesWithSameLabelAndPropertyAsEqual() throws Exception
{
// given
SchemaIndexProvider.Descriptor descriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
SchemaRuleContent rule1 = new SchemaRuleContent( constraintIndexRule( 0, 1, 2, descriptor, null ) );
SchemaRuleContent rule2 = new SchemaRuleContent( constraintIndexRule( 1, 1, 2, descriptor, 4l ) );
// then
assertReflectivelyEquals( rule1, rule2 );
}
@Test
public void shouldReportUniquenessConstraintRulesWithSameLabelAndPropertyAsEqual() throws Exception
{
// given
SchemaRuleContent rule1 = new SchemaRuleContent( uniquenessConstraintRule( 0, 1, 2, 0 ) );
SchemaRuleContent rule2 = new SchemaRuleContent( uniquenessConstraintRule( 1, 1, 2, 0 ) );
// then
assertReflectivelyEquals( rule1, rule2 );
}
@Test
public void shouldReportIndexRulesWithSameLabelButDifferentPropertyAsNotEqual() throws Exception
{
// given
SchemaIndexProvider.Descriptor descriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
SchemaRuleContent rule1 = new SchemaRuleContent( indexRule( 0, 1, 2, descriptor ) );
SchemaRuleContent rule2 = new SchemaRuleContent( indexRule( 1, 1, 3, descriptor ) );
// then
assertReflectivelyNotEquals( rule1, rule2 );
}
@Test
public void shouldReportIndexRulesWithSamePropertyButDifferentLabelAsNotEqual() throws Exception
{
// given
SchemaIndexProvider.Descriptor descriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
SchemaRuleContent rule1 = new SchemaRuleContent( indexRule( 0, 1, 2, descriptor ) );
SchemaRuleContent rule2 = new SchemaRuleContent( indexRule( 1, 4, 2, descriptor ) );
// then
assertReflectivelyNotEquals( rule1, rule2 );
}
@Test
public void shouldReportIndexRuleAndUniquenessConstraintAsNotEqual() throws Exception
{
// given
SchemaIndexProvider.Descriptor descriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
SchemaRuleContent rule1 = new SchemaRuleContent( indexRule( 0, 1, 2, descriptor ) );
SchemaRuleContent rule2 = new SchemaRuleContent( uniquenessConstraintRule( 1, 1, 2, 0 ) );
// then
assertReflectivelyNotEquals( rule1, rule2 );
}
@Test
public void shouldReportConstraintIndexRuleAndUniquenessConstraintAsNotEqual() throws Exception
{
// given
SchemaIndexProvider.Descriptor descriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
SchemaRuleContent rule1 = new SchemaRuleContent( constraintIndexRule( 0, 1, 2, descriptor, null ) );
SchemaRuleContent rule2 = new SchemaRuleContent( uniquenessConstraintRule( 1, 1, 2, 0 ) );
// then
assertReflectivelyNotEquals( rule1, rule2 );
}
@Test
public void shouldReportIndexRuleAndUniqueIndexRuleWithSameLabelAndPropertyAsEqual() throws Exception
{
// given
SchemaIndexProvider.Descriptor descriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
SchemaRuleContent rule1 = new SchemaRuleContent( indexRule( 0, 1, 2, descriptor ) );
SchemaRuleContent rule2 = new SchemaRuleContent( constraintIndexRule( 1, 1, 2, descriptor, null ) );
// then
assertReflectivelyEquals( rule1, rule2 );
}
private static void assertReflectivelyEquals( Object lhs, Object rhs )
{
assertEquals( "lhs should be equal to rhs", lhs, rhs );
assertEquals( "rhs should be equal to lhs", rhs, lhs );
assertEquals( "hash codes should be equal", lhs.hashCode(), rhs.hashCode() );
}
private static void assertReflectivelyNotEquals( Object lhs, Object rhs )
{
assertNotEquals( "lhs should not be equal to rhs", lhs, rhs );
assertNotEquals( "rhs should not be equal to lhs", rhs, lhs );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_SchemaRuleContentTest.java
|
4,114
|
PREV( Record.NO_PREVIOUS_PROPERTY )
{
@Override
public long valueFrom( PropertyRecord record )
{
return record.getPrevProp();
}
@Override
long otherReference( PropertyRecord record )
{
return record.getNextProp();
}
@Override
void notInUse( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property )
{
report.prevNotInUse( property );
}
@Override
void noBackReference( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property )
{
report.previousDoesNotReferenceBack( property );
}
@Override
void reportNotUpdated( ConsistencyReport.PropertyConsistencyReport report )
{
report.prevNotUpdated();
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PropertyRecordCheck.java
|
4,115
|
{
@Override
void notUsed( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.stringNotInUse( block, value );
}
@Override
void empty( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.stringEmpty( block, value );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PropertyRecordCheck.java
|
4,116
|
{
@Override
public RecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> decorateNeoStoreChecker(
PrimitiveRecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> checker )
{
return checker;
}
@Override
public RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> decorateNodeChecker(
PrimitiveRecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> checker )
{
return checker;
}
@Override
public RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> decorateRelationshipChecker(
PrimitiveRecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> checker )
{
return checker;
}
@Override
public RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> decoratePropertyChecker(
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> checker )
{
return checker;
}
@Override
public RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> decoratePropertyKeyTokenChecker(
RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> checker )
{
return checker;
}
@Override
public RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> decorateRelationshipTypeTokenChecker(
RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> checker )
{
return checker;
}
@Override
public RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport> decorateLabelTokenChecker(
RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport> checker )
{
return checker;
}
@Override
public RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> decorateLabelMatchChecker(
RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> checker )
{
return checker;
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_CheckDecorator.java
|
4,117
|
class NeoStoreCheck extends PrimitiveRecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport>
{
// nothing added over PrimitiveRecordCheck
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NeoStoreCheck.java
|
4,118
|
class LabelTokenRecordCheck
extends TokenRecordCheck<LabelTokenRecord,ConsistencyReport.LabelTokenConsistencyReport>
{
@Override
protected RecordReference<DynamicRecord> name( RecordAccess records, int id )
{
return records.labelName( id );
}
@Override
void nameNotInUse( ConsistencyReport.LabelTokenConsistencyReport report, DynamicRecord name )
{
report.nameBlockNotInUse( name );
}
@Override
void emptyName( ConsistencyReport.LabelTokenConsistencyReport report, DynamicRecord name )
{
report.emptyName( name );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_LabelTokenRecordCheck.java
|
4,119
|
public class LabelChainWalker<RECORD extends AbstractBaseRecord, REPORT extends ConsistencyReport> implements
ComparativeRecordChecker<RECORD, DynamicRecord, REPORT>
{
private final Validator<RECORD, REPORT> validator;
private HashMap<Long, DynamicRecord> recordIds = new HashMap<>();
private List<DynamicRecord> recordList = new ArrayList<>();
private boolean allInUse = true;
public LabelChainWalker( Validator<RECORD, REPORT> validator )
{
this.validator = validator;
}
@Override
public void checkReference( RECORD record, DynamicRecord dynamicRecord,
CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
recordIds.put( dynamicRecord.getId(), dynamicRecord );
if ( dynamicRecord.inUse() )
{
recordList.add( dynamicRecord );
}
else
{
allInUse = false;
validator.onRecordNotInUse( dynamicRecord, engine );
}
long nextBlock = dynamicRecord.getNextBlock();
if ( Record.NO_NEXT_BLOCK.is( nextBlock ) )
{
if ( allInUse )
{
// only validate label ids if all dynamic records seen were in use
validator.onWellFormedChain( labelIds( recordList ), engine, records );
}
}
else
{
if ( recordIds.containsKey( nextBlock ) )
{
validator.onRecordChainCycle( recordIds.get( nextBlock ), engine );
}
else
{
engine.comparativeCheck( records.nodeLabels( nextBlock ), this );
}
}
}
private long[] labelIds( List<DynamicRecord> recordList )
{
long[] idArray =
(long[]) getRightArray( readFullByteArrayFromHeavyRecords( recordList, PropertyType.ARRAY ) );
return LabelIdArray.stripNodeId( idArray );
}
public interface Validator<RECORD extends AbstractBaseRecord, REPORT extends ConsistencyReport>
{
void onRecordNotInUse( DynamicRecord dynamicRecord, CheckerEngine<RECORD, REPORT> engine );
void onRecordChainCycle( DynamicRecord record, CheckerEngine<RECORD, REPORT> engine );
void onWellFormedChain( long[] labelIds, CheckerEngine<RECORD, REPORT> engine, RecordAccess records );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_LabelChainWalker.java
|
4,120
|
public class InconsistentStoreException extends Throwable
{
private final ConsistencySummaryStatistics summary;
public InconsistentStoreException( ConsistencySummaryStatistics summary )
{
super( summary.toString() );
this.summary = summary;
}
public ConsistencySummaryStatistics summary()
{
return summary;
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_InconsistentStoreException.java
|
4,121
|
public static final class TransactionDataBuilder
{
private final TransactionWriter writer;
public TransactionDataBuilder( TransactionWriter writer )
{
this.writer = writer;
}
public void createSchema( Collection<DynamicRecord> beforeRecords, Collection<DynamicRecord> afterRecords )
{
try
{
writer.createSchema( beforeRecords, afterRecords );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void propertyKey( int id, String key )
{
try
{
writer.propertyKey( id, key, id );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void nodeLabel( int id, String name )
{
try
{
writer.label( id, name, id );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void relationshipType( int id, String relationshipType )
{
try
{
writer.relationshipType( id, relationshipType, id );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void create( NodeRecord node )
{
try
{
writer.create( node );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( NeoStoreRecord record )
{
try
{
writer.update( record );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( NodeRecord before, NodeRecord after )
{
try
{
writer.update( before, after );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void delete( NodeRecord node )
{
try
{
writer.delete( node );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void create( RelationshipRecord relationship )
{
try
{
writer.create( relationship );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( RelationshipRecord relationship )
{
try
{
writer.update( relationship );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void delete( RelationshipRecord relationship )
{
try
{
writer.delete( relationship );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void create( PropertyRecord property )
{
try
{
writer.create( property );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( PropertyRecord before, PropertyRecord property )
{
try
{
writer.update( before, property );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void delete( PropertyRecord before, PropertyRecord property )
{
try
{
writer.delete( before, property );
}
catch ( IOException e )
{
throw ioError( e );
}
}
private Error ioError( IOException e )
{
return new Error( "InMemoryLogBuffer should not throw IOException", e );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_GraphStoreFixture.java
|
4,122
|
public static abstract class Transaction
{
public final long startTimestamp = System.currentTimeMillis();
public final byte[] globalId = XidImpl.getNewGlobalId( DEFAULT_SEED, -1 );
protected abstract void transactionData( TransactionDataBuilder tx, IdGenerator next );
private ReadableByteChannel write( IdGenerator idGenerator, int identifier, int masterId, int myId, long txId )
throws IOException
{
InMemoryLogBuffer buffer = new InMemoryLogBuffer();
TransactionWriter writer = new TransactionWriter( buffer, identifier, myId );
writer.start( globalId, masterId, myId, startTimestamp, txId );
transactionData( new TransactionDataBuilder( writer ), idGenerator );
writer.prepare();
return buffer;
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_GraphStoreFixture.java
|
4,123
|
public class IdGenerator
{
public long schema()
{
return schemaId++;
}
public long node()
{
return nodeId++;
}
public int label()
{
return labelId++;
}
public long nodeLabel()
{
return nodeLabelsId++;
}
public long relationship()
{
return relId++;
}
public long property()
{
return propId++;
}
public long stringProperty()
{
return stringPropId++;
}
public long arrayProperty()
{
return arrayPropId++;
}
public int relationshipType()
{
return relTypeId++;
}
public int propertyKey()
{
return propKeyId++;
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_GraphStoreFixture.java
|
4,124
|
{
@Override
public void evaluate() throws Throwable
{
GraphStoreFixture.this.directory = directory.directory().getAbsolutePath();
try
{
generateInitialData();
start( GraphStoreFixture.this.directory );
try
{
base.evaluate();
}
finally
{
stop();
}
}
finally
{
GraphStoreFixture.this.directory = null;
}
}
}, description );
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_GraphStoreFixture.java
|
4,125
|
public abstract class GraphStoreFixture implements TestRule
{
private DirectStoreAccess directStoreAccess;
public void apply( Transaction transaction ) throws IOException
{
applyTransaction( transaction );
}
public DirectStoreAccess directStoreAccess()
{
if ( directStoreAccess == null )
{
StoreAccess nativeStores = new StoreAccess( directory );
directStoreAccess = new DirectStoreAccess(
nativeStores,
new LuceneLabelScanStoreBuilder(
directory().getAbsolutePath(),
nativeStores.getRawNeoStore(),
new DefaultFileSystemAbstraction(),
StringLogger.SYSTEM
).build(),
createIndexes()
);
}
return directStoreAccess;
}
private SchemaIndexProvider createIndexes()
{
Config config = new Config( singletonMap( GraphDatabaseSettings.store_dir.name(),
directory().getAbsolutePath() ) );
return new LuceneSchemaIndexProvider( DirectoryFactory.PERSISTENT, config );
}
public File directory()
{
return new File( directory );
}
public static abstract class Transaction
{
public final long startTimestamp = System.currentTimeMillis();
public final byte[] globalId = XidImpl.getNewGlobalId( DEFAULT_SEED, -1 );
protected abstract void transactionData( TransactionDataBuilder tx, IdGenerator next );
private ReadableByteChannel write( IdGenerator idGenerator, int identifier, int masterId, int myId, long txId )
throws IOException
{
InMemoryLogBuffer buffer = new InMemoryLogBuffer();
TransactionWriter writer = new TransactionWriter( buffer, identifier, myId );
writer.start( globalId, masterId, myId, startTimestamp, txId );
transactionData( new TransactionDataBuilder( writer ), idGenerator );
writer.prepare();
return buffer;
}
}
public IdGenerator idGenerator()
{
return new IdGenerator();
}
public class IdGenerator
{
public long schema()
{
return schemaId++;
}
public long node()
{
return nodeId++;
}
public int label()
{
return labelId++;
}
public long nodeLabel()
{
return nodeLabelsId++;
}
public long relationship()
{
return relId++;
}
public long property()
{
return propId++;
}
public long stringProperty()
{
return stringPropId++;
}
public long arrayProperty()
{
return arrayPropId++;
}
public int relationshipType()
{
return relTypeId++;
}
public int propertyKey()
{
return propKeyId++;
}
}
public static final class TransactionDataBuilder
{
private final TransactionWriter writer;
public TransactionDataBuilder( TransactionWriter writer )
{
this.writer = writer;
}
public void createSchema( Collection<DynamicRecord> beforeRecords, Collection<DynamicRecord> afterRecords )
{
try
{
writer.createSchema( beforeRecords, afterRecords );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void propertyKey( int id, String key )
{
try
{
writer.propertyKey( id, key, id );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void nodeLabel( int id, String name )
{
try
{
writer.label( id, name, id );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void relationshipType( int id, String relationshipType )
{
try
{
writer.relationshipType( id, relationshipType, id );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void create( NodeRecord node )
{
try
{
writer.create( node );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( NeoStoreRecord record )
{
try
{
writer.update( record );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( NodeRecord before, NodeRecord after )
{
try
{
writer.update( before, after );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void delete( NodeRecord node )
{
try
{
writer.delete( node );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void create( RelationshipRecord relationship )
{
try
{
writer.create( relationship );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( RelationshipRecord relationship )
{
try
{
writer.update( relationship );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void delete( RelationshipRecord relationship )
{
try
{
writer.delete( relationship );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void create( PropertyRecord property )
{
try
{
writer.create( property );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void update( PropertyRecord before, PropertyRecord property )
{
try
{
writer.update( before, property );
}
catch ( IOException e )
{
throw ioError( e );
}
}
public void delete( PropertyRecord before, PropertyRecord property )
{
try
{
writer.delete( before, property );
}
catch ( IOException e )
{
throw ioError( e );
}
}
private Error ioError( IOException e )
{
return new Error( "InMemoryLogBuffer should not throw IOException", e );
}
}
protected abstract void generateInitialData( GraphDatabaseService graphDb );
protected void start( @SuppressWarnings("UnusedParameters") String storeDir )
{
// allow for override
}
protected void stop() throws Throwable
{
if ( directStoreAccess != null )
{
directStoreAccess.close();
directStoreAccess = null;
}
}
protected int myId()
{
return 1;
}
protected int masterId()
{
return -1;
}
protected final ReadableByteChannel write( Transaction transaction, Long txId ) throws IOException
{
return transaction.write( idGenerator(), localIdGenerator++, masterId(), myId(), txId );
}
@SuppressWarnings("deprecation")
protected void applyTransaction( Transaction transaction ) throws IOException
{
GraphDatabaseAPI database = (GraphDatabaseAPI) new GraphDatabaseFactory().newEmbeddedDatabaseBuilder( directory ).setConfig( configuration( false ) ).newGraphDatabase();
try ( org.neo4j.graphdb.Transaction tx = database.beginTx() )
{
DependencyResolver resolver = database.getDependencyResolver();
XaDataSourceManager xaDataSourceManager = resolver.resolveDependency( XaDataSourceManager.class );
NeoStoreXaDataSource dataSource = xaDataSourceManager.getNeoStoreDataSource();
dataSource.applyPreparedTransaction( write( transaction, dataSource.getLastCommittedTxId() ) );
}
finally
{
database.shutdown();
}
}
protected Map<String, String> configuration( boolean initialData )
{
return new HashMap<>();
}
private String directory;
private int localIdGenerator = 0;
private long schemaId;
private long nodeId;
private int labelId;
private long nodeLabelsId;
private long relId;
private int propId;
private long stringPropId;
private long arrayPropId;
private int relTypeId;
private int propKeyId;
private void generateInitialData()
{
GraphDatabaseAPI graphDb = (GraphDatabaseAPI) new GraphDatabaseFactory().newEmbeddedDatabaseBuilder( directory ).setConfig( configuration( true ) ).newGraphDatabase();
try
{
generateInitialData( graphDb );
StoreAccess stores = new StoreAccess( graphDb );
schemaId = stores.getSchemaStore().getHighId();
nodeId = stores.getNodeStore().getHighId();
labelId = (int) stores.getLabelTokenStore().getHighId();
nodeLabelsId = stores.getNodeDynamicLabelStore().getHighId();
relId = stores.getRelationshipStore().getHighId();
propId = (int) stores.getPropertyStore().getHighId();
stringPropId = stores.getStringStore().getHighId();
arrayPropId = stores.getArrayStore().getHighId();
relTypeId = (int) stores.getRelationshipTypeTokenStore().getHighId();
propKeyId = (int) stores.getPropertyKeyNameStore().getHighId();
}
finally
{
graphDb.shutdown();
}
}
@Override
public Statement apply( final Statement base, Description description )
{
final TargetDirectory.TestDirectory directory = TargetDirectory.forTest( description.getTestClass() )
.testDirectory();
return directory.apply( new Statement()
{
@Override
public void evaluate() throws Throwable
{
GraphStoreFixture.this.directory = directory.directory().getAbsolutePath();
try
{
generateInitialData();
start( GraphStoreFixture.this.directory );
try
{
base.evaluate();
}
finally
{
stop();
}
}
finally
{
GraphStoreFixture.this.directory = null;
}
}
}, description );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_GraphStoreFixture.java
|
4,126
|
NODE_LABEL( RecordType.NODE_DYNAMIC_LABEL )
{
@Override
RecordReference<DynamicRecord> lookup( RecordAccess records, long block )
{
return records.nodeLabels( block );
}
@Override
DynamicRecord changed( DiffRecordAccess records, long id )
{
return null; // never needed (?)
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_DynamicStore.java
|
4,127
|
LABEL( RecordType.LABEL_NAME )
{
@Override
RecordReference<DynamicRecord> lookup( RecordAccess records, long block )
{
return records.labelName( (int) block );
}
@Override
DynamicRecord changed( DiffRecordAccess records, long id )
{
return null; // never needed
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_DynamicStore.java
|
4,128
|
RELATIONSHIP_TYPE( RecordType.RELATIONSHIP_TYPE_NAME )
{
@Override
RecordReference<DynamicRecord> lookup( RecordAccess records, long block )
{
return records.relationshipTypeName( (int) block );
}
@Override
DynamicRecord changed( DiffRecordAccess records, long id )
{
return null; // never needed
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_DynamicStore.java
|
4,129
|
PROPERTY_KEY( RecordType.PROPERTY_KEY_NAME )
{
@Override
RecordReference<DynamicRecord> lookup( RecordAccess records, long block )
{
return records.propertyKeyName( (int) block );
}
@Override
DynamicRecord changed( DiffRecordAccess records, long id )
{
return null; // never needed
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_DynamicStore.java
|
4,130
|
ARRAY( RecordType.ARRAY_PROPERTY )
{
@Override
RecordReference<DynamicRecord> lookup( RecordAccess records, long block )
{
return records.array( block );
}
@Override
DynamicRecord changed( DiffRecordAccess records, long id )
{
return records.changedArray( id );
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_DynamicStore.java
|
4,131
|
STRING( RecordType.STRING_PROPERTY )
{
@Override
RecordReference<DynamicRecord> lookup( RecordAccess records, long block )
{
return records.string( block );
}
@Override
DynamicRecord changed( DiffRecordAccess records, long id )
{
return records.changedString( id );
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_DynamicStore.java
|
4,132
|
SCHEMA( RecordType.SCHEMA )
{
@Override
RecordReference<DynamicRecord> lookup( RecordAccess records, long block )
{
return records.schema( block );
}
@Override
DynamicRecord changed( DiffRecordAccess records, long id )
{
return records.changedSchema( id );
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_DynamicStore.java
|
4,133
|
@RunWith(JUnit4.class)
public static class StringDynamicRecordCheckTest extends DynamicRecordCheckTest
{
public StringDynamicRecordCheckTest()
{
super( new DynamicRecordCheck( configureDynamicStore( 66 ), DynamicStore.STRING ), 66 );
}
@Override
DynamicRecord record( long id )
{
return string( new DynamicRecord( id ) );
}
@Override
DynamicRecord fill( DynamicRecord record, int size )
{
record.setLength( size );
return record;
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_DynamicRecordCheckTest.java
|
4,134
|
@RunWith(JUnit4.class)
public static class SchemaDynamicRecordCheckTest extends DynamicRecordCheckTest
{
public SchemaDynamicRecordCheckTest()
{
super( new DynamicRecordCheck( configureDynamicStore( SchemaStore.BLOCK_SIZE ), DynamicStore.SCHEMA ),
SchemaStore.BLOCK_SIZE );
}
@Override
DynamicRecord record( long id )
{
DynamicRecord result = new DynamicRecord( id );
result.setType( SCHEMA_RECORD_TYPE );
return result;
}
@Override
DynamicRecord fill( DynamicRecord record, int size )
{
record.setLength( size );
return record;
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_DynamicRecordCheckTest.java
|
4,135
|
@RunWith(JUnit4.class)
public static class ArrayDynamicRecordCheckTest extends DynamicRecordCheckTest
{
public ArrayDynamicRecordCheckTest()
{
super( new DynamicRecordCheck( configureDynamicStore( 66 ), DynamicStore.ARRAY ), 66 );
}
@Override
DynamicRecord record( long id )
{
return array( new DynamicRecord( id ) );
}
@Override
DynamicRecord fill( DynamicRecord record, int size )
{
record.setLength( size );
return record;
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_DynamicRecordCheckTest.java
|
4,136
|
@RunWith(Suite.class)
@Suite.SuiteClasses( {
DynamicRecordCheckTest.StringDynamicRecordCheckTest.class,
DynamicRecordCheckTest.ArrayDynamicRecordCheckTest.class,
DynamicRecordCheckTest.SchemaDynamicRecordCheckTest.class
} )
public abstract class DynamicRecordCheckTest
extends RecordCheckTestBase<DynamicRecord,ConsistencyReport.DynamicConsistencyReport,DynamicRecordCheck>
{
private final int blockSize;
private DynamicRecordCheckTest( DynamicRecordCheck check, int blockSize )
{
super( check, ConsistencyReport.DynamicConsistencyReport.class );
this.blockSize = blockSize;
}
@Test
public void shouldNotReportAnythingForRecordNotInUse() throws Exception
{
// given
DynamicRecord property = notInUse( record( 42 ) );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingForRecordThatDoesNotReferenceOtherRecords() throws Exception
{
// given
DynamicRecord property = inUse( fill( record( 42 ), blockSize / 2 ) );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingForRecordWithConsistentReferences() throws Exception
{
// given
DynamicRecord property = inUse( fill( record( 42 ) ) );
DynamicRecord next = add( inUse( fill( record( 7 ), blockSize / 2 ) ) );
property.setNextBlock( next.getId() );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportNextRecordNotInUse() throws Exception
{
// given
DynamicRecord property = inUse( fill( record( 42 ) ) );
DynamicRecord next = add( notInUse( record( 7 ) ) );
property.setNextBlock( next.getId() );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verify( report ).nextNotInUse( next );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportSelfReferentialNext() throws Exception
{
// given
DynamicRecord property = add( inUse( fill( record( 42 ) ) ) );
property.setNextBlock( property.getId() );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verify( report ).selfReferentialNext();
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportNonFullRecordWithNextReference() throws Exception
{
// given
DynamicRecord property = inUse( fill( record( 42 ), blockSize - 1 ) );
DynamicRecord next = add( inUse( fill( record( 7 ), blockSize / 2 ) ) );
property.setNextBlock( next.getId() );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verify( report ).recordNotFullReferencesNext();
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportInvalidDataLength() throws Exception
{
// given
DynamicRecord property = inUse( record( 42 ) );
property.setLength( -1 );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verify( report ).invalidLength();
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportEmptyRecord() throws Exception
{
// given
DynamicRecord property = inUse( record( 42 ) );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verify( report ).emptyBlock();
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportRecordWithEmptyNext() throws Exception
{
// given
DynamicRecord property = inUse( fill( record( 42 ) ) );
DynamicRecord next = add( inUse( record( 7 ) ) );
property.setNextBlock( next.getId() );
// when
ConsistencyReport.DynamicConsistencyReport report = check( property );
// then
verify( report ).emptyNextBlock( next );
verifyNoMoreInteractions( report );
}
// change checking
@Test
public void shouldNotReportAnythingForConsistentlyChangedRecord() throws Exception
{
// given
DynamicRecord oldProperty = fill( inUse( record( 42 ) ) );
DynamicRecord newProperty = fill( inUse( record( 42 ) ) );
DynamicRecord oldNext = fill( inUse( record( 10 ) ), 1 );
addChange( oldNext, notInUse( record( 10 ) ) );
DynamicRecord newNext = addChange( notInUse( record( 20 ) ),
fill( inUse( record( 20 ) ), 1 ) );
oldProperty.setNextBlock( oldNext.getId() );
newProperty.setNextBlock( newNext.getId() );
// when
ConsistencyReport.DynamicConsistencyReport report = checkChange( oldProperty, newProperty );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportProblemsWithTheNewStateWhenCheckingChanges() throws Exception
{
// given
DynamicRecord oldProperty = notInUse( record( 42 ) );
DynamicRecord newProperty = inUse( record( 42 ) );
// when
ConsistencyReport.DynamicConsistencyReport report = checkChange( oldProperty, newProperty );
// then
verify( report ).emptyBlock();
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportNextReferenceChangedButPreviouslyReferencedRecordNotUpdated() throws Exception
{
// given
DynamicRecord oldProperty = fill( inUse( record( 42 ) ) );
DynamicRecord newProperty = fill( inUse( record( 42 ) ) );
oldProperty.setNextBlock( add( fill( inUse( record( 1 ) ) ) ).getId() );
newProperty.setNextBlock( addChange( notInUse( record( 2 ) ),
fill( inUse( record( 2 ) ) ) ).getId() );
// when
ConsistencyReport.DynamicConsistencyReport report = checkChange( oldProperty, newProperty );
// then
verify( report ).nextNotUpdated();
verifyNoMoreInteractions( report );
}
// utilities
DynamicRecord fill( DynamicRecord record )
{
return fill( record, blockSize );
}
abstract DynamicRecord fill( DynamicRecord record, int size );
abstract DynamicRecord record( long id );
@RunWith(JUnit4.class)
public static class StringDynamicRecordCheckTest extends DynamicRecordCheckTest
{
public StringDynamicRecordCheckTest()
{
super( new DynamicRecordCheck( configureDynamicStore( 66 ), DynamicStore.STRING ), 66 );
}
@Override
DynamicRecord record( long id )
{
return string( new DynamicRecord( id ) );
}
@Override
DynamicRecord fill( DynamicRecord record, int size )
{
record.setLength( size );
return record;
}
}
@RunWith(JUnit4.class)
public static class ArrayDynamicRecordCheckTest extends DynamicRecordCheckTest
{
public ArrayDynamicRecordCheckTest()
{
super( new DynamicRecordCheck( configureDynamicStore( 66 ), DynamicStore.ARRAY ), 66 );
}
@Override
DynamicRecord record( long id )
{
return array( new DynamicRecord( id ) );
}
@Override
DynamicRecord fill( DynamicRecord record, int size )
{
record.setLength( size );
return record;
}
}
@RunWith(JUnit4.class)
public static class SchemaDynamicRecordCheckTest extends DynamicRecordCheckTest
{
public SchemaDynamicRecordCheckTest()
{
super( new DynamicRecordCheck( configureDynamicStore( SchemaStore.BLOCK_SIZE ), DynamicStore.SCHEMA ),
SchemaStore.BLOCK_SIZE );
}
@Override
DynamicRecord record( long id )
{
DynamicRecord result = new DynamicRecord( id );
result.setType( SCHEMA_RECORD_TYPE );
return result;
}
@Override
DynamicRecord fill( DynamicRecord record, int size )
{
record.setLength( size );
return record;
}
}
public static RecordStore<DynamicRecord> configureDynamicStore( int blockSize )
{
@SuppressWarnings( "unchecked" )
RecordStore<DynamicRecord> mock = mock( RecordStore.class );
when( mock.getRecordSize() ).thenReturn( blockSize + AbstractDynamicStore.BLOCK_HEADER_SIZE );
when( mock.getRecordHeaderSize() ).thenReturn( AbstractDynamicStore.BLOCK_HEADER_SIZE );
return mock;
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_DynamicRecordCheckTest.java
|
4,137
|
public class LabelTokenRecordCheckTest extends
RecordCheckTestBase<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport, LabelTokenRecordCheck>
{
public LabelTokenRecordCheckTest()
{
super( new LabelTokenRecordCheck(), ConsistencyReport.LabelTokenConsistencyReport.class );
}
@Test
public void shouldNotReportAnythingForRecordNotInUse() throws Exception
{
// given
LabelTokenRecord key = notInUse( new LabelTokenRecord( 42 ) );
// when
ConsistencyReport.LabelTokenConsistencyReport report = check( key );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingForRecordThatDoesNotReferenceADynamicBlock() throws Exception
{
// given
LabelTokenRecord key = inUse( new LabelTokenRecord( 42 ) );
// when
ConsistencyReport.LabelTokenConsistencyReport report = check( key );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportDynamicBlockNotInUse() throws Exception
{
// given
LabelTokenRecord key = inUse( new LabelTokenRecord( 42 ) );
DynamicRecord name = addLabelName( notInUse( new DynamicRecord( 6 ) ) );
key.setNameId( (int) name.getId() );
// when
ConsistencyReport.LabelTokenConsistencyReport report = check( key );
// then
verify( report ).nameBlockNotInUse( name );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportEmptyName() throws Exception
{
// given
LabelTokenRecord key = inUse( new LabelTokenRecord( 42 ) );
DynamicRecord name = addLabelName( inUse( new DynamicRecord( 6 ) ) );
key.setNameId( (int) name.getId() );
// when
ConsistencyReport.LabelTokenConsistencyReport report = check( key );
// then
verify( report ).emptyName( name );
verifyNoMoreInteractions( report );
}
// change checking
@Test
public void shouldNotReportAnythingForConsistentlyChangedRecord() throws Exception
{
// given
LabelTokenRecord oldRecord = notInUse( new LabelTokenRecord( 42 ) );
LabelTokenRecord newRecord = inUse( new LabelTokenRecord( 42 ) );
DynamicRecord name = addLabelName( inUse( new DynamicRecord( 6 ) ) );
name.setData( new byte[1] );
newRecord.setNameId( (int) name.getId() );
// when
ConsistencyReport.LabelTokenConsistencyReport report = checkChange( oldRecord, newRecord );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportProblemsWithTheNewStateWhenCheckingChanges() throws Exception
{
// given
LabelTokenRecord oldRecord = notInUse( new LabelTokenRecord( 42 ) );
LabelTokenRecord newRecord = inUse( new LabelTokenRecord( 42 ) );
DynamicRecord name = addLabelName( notInUse( new DynamicRecord( 6 ) ) );
newRecord.setNameId( (int) name.getId() );
// when
ConsistencyReport.LabelTokenConsistencyReport report = checkChange( oldRecord, newRecord );
// then
verify( report ).nameBlockNotInUse( name );
verifyNoMoreInteractions( report );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_LabelTokenRecordCheckTest.java
|
4,138
|
public class NeoStoreCheckTest
extends RecordCheckTestBase<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport, NeoStoreCheck>
{
public NeoStoreCheckTest()
{
super( new NeoStoreCheck(), ConsistencyReport.NeoStoreConsistencyReport.class );
}
@Test
public void shouldNotReportAnythingForRecordWithNoPropertyReference() throws Exception
{
// given
NeoStoreRecord record = new NeoStoreRecord();
// when
ConsistencyReport.NeoStoreConsistencyReport report = check( record );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingForRecordWithConsistentReferenceToProperty() throws Exception
{
// given
NeoStoreRecord record = new NeoStoreRecord();
record.setNextProp( add( inUse( new PropertyRecord( 7 ) ) ).getId() );
// when
ConsistencyReport.NeoStoreConsistencyReport report = check( record );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportPropertyNotInUse() throws Exception
{
// given
NeoStoreRecord record = new NeoStoreRecord();
PropertyRecord property = add( notInUse( new PropertyRecord( 7 ) ) );
record.setNextProp( property.getId() );
// when
ConsistencyReport.NeoStoreConsistencyReport report = check( record );
// then
verify( report ).propertyNotInUse( property );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportPropertyNotFirstInChain() throws Exception
{
// given
NeoStoreRecord record = new NeoStoreRecord();
PropertyRecord property = add( inUse( new PropertyRecord( 7 ) ) );
property.setPrevProp( 6 );
record.setNextProp( property.getId() );
// when
ConsistencyReport.NeoStoreConsistencyReport report = check( record );
// then
verify( report ).propertyNotFirstInChain( property );
verifyNoMoreInteractions( report );
}
// Change checking
@Test
public void shouldNotReportAnythingForConsistentlyChangedRecord() throws Exception
{
// given
NeoStoreRecord oldRecord = new NeoStoreRecord();
NeoStoreRecord newRecord = new NeoStoreRecord();
oldRecord.setNextProp( addChange( inUse( new PropertyRecord( 1 ) ),
notInUse( new PropertyRecord( 1 ) ) ).getId() );
newRecord.setNextProp( addChange( notInUse( new PropertyRecord( 2 ) ),
inUse( new PropertyRecord( 2 ) ) ).getId() );
// when
ConsistencyReport.NeoStoreConsistencyReport report = checkChange( oldRecord, newRecord );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportProblemsWithTheNewStateWhenCheckingChanges() throws Exception
{
// given
NeoStoreRecord oldRecord = new NeoStoreRecord();
NeoStoreRecord newRecord = new NeoStoreRecord();
oldRecord.setNextProp( addChange( inUse( new PropertyRecord( 1 ) ),
notInUse( new PropertyRecord( 1 ) ) ).getId() );
PropertyRecord property = addChange( notInUse( new PropertyRecord( 2 ) ),
inUse( new PropertyRecord( 2 ) ) );
property.setPrevProp( 10 );
newRecord.setNextProp( property.getId() );
// when
ConsistencyReport.NeoStoreConsistencyReport report = checkChange( oldRecord, newRecord );
// then
verify( report ).propertyNotFirstInChain( property );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportPropertyChainReplacedButNotUpdated() throws Exception
{
// given
NeoStoreRecord oldRecord = new NeoStoreRecord();
NeoStoreRecord newRecord = new NeoStoreRecord();
oldRecord.setNextProp( add( inUse( new PropertyRecord( 1 ) ) ).getId() );
newRecord.setNextProp( addChange( notInUse( new PropertyRecord( 2 ) ),
inUse( new PropertyRecord( 2 ) ) ).getId() );
// when
ConsistencyReport.NeoStoreConsistencyReport report = checkChange( oldRecord, newRecord );
// then
verify( report ).propertyNotUpdated();
verifyNoMoreInteractions( report );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_NeoStoreCheckTest.java
|
4,139
|
private static abstract class DynamicReference implements
ComparativeRecordChecker<PropertyRecord, DynamicRecord, ConsistencyReport.PropertyConsistencyReport>
{
final PropertyBlock block;
private DynamicReference( PropertyBlock block )
{
this.block = block;
}
public static DynamicReference string( PropertyBlock block )
{
return new DynamicReference( block )
{
@Override
void notUsed( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.stringNotInUse( block, value );
}
@Override
void empty( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.stringEmpty( block, value );
}
};
}
public static DynamicReference array( PropertyBlock block )
{
return new DynamicReference( block )
{
@Override
void notUsed( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.arrayNotInUse( block, value );
}
@Override
void empty( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.arrayEmpty( block, value );
}
};
}
@Override
public void checkReference( PropertyRecord record, DynamicRecord referred,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !referred.inUse() )
{
notUsed( engine.report(), referred );
}
else
{
if ( referred.getLength() <= 0 )
{
empty( engine.report(), referred );
}
}
}
abstract void notUsed( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value );
abstract void empty( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value );
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PropertyRecordCheck.java
|
4,140
|
public class NodeDynamicLabelOrphanChainStartCheck
implements RecordCheck<DynamicRecord, DynamicLabelConsistencyReport>,
ComparativeRecordChecker<DynamicRecord, DynamicRecord, DynamicLabelConsistencyReport>
{
private static final
ComparativeRecordChecker<DynamicRecord, NodeRecord, DynamicLabelConsistencyReport> VALID_NODE_RECORD =
new ComparativeRecordChecker<DynamicRecord, NodeRecord, DynamicLabelConsistencyReport>()
{
@Override
public void checkReference( DynamicRecord record, NodeRecord nodeRecord,
CheckerEngine<DynamicRecord, DynamicLabelConsistencyReport> engine,
RecordAccess records )
{
if ( ! nodeRecord.inUse() )
{
// if this node record is not in use it is not a valid owner
engine.report().orphanDynamicLabelRecordDueToInvalidOwner( nodeRecord );
}
else
{
// if this node record is in use but doesn't point to the dynamic label record
// that label record has an invalid owner
Long dynamicLabelRecordId = fieldDynamicLabelRecordId( nodeRecord.getLabelField() );
long recordId = record.getLongId();
if ( dynamicLabelRecordId == null || dynamicLabelRecordId.longValue() != recordId )
{
engine.report().orphanDynamicLabelRecordDueToInvalidOwner( nodeRecord );
}
}
}
};
@Override
public void check( DynamicRecord record,
CheckerEngine<DynamicRecord, DynamicLabelConsistencyReport> engine,
RecordAccess records )
{
if ( record.inUse() && record.isStartRecord() )
{
Long ownerId = readOwnerFromDynamicLabelsRecord( record );
if ( null == ownerId )
{
// no owner but in use indicates a broken record
engine.report().orphanDynamicLabelRecord();
}
else
{
// look at owning node record to verify consistency
engine.comparativeCheck( records.node( ownerId ), VALID_NODE_RECORD );
}
}
}
@Override
public void checkChange( DynamicRecord oldRecord, DynamicRecord newRecord,
CheckerEngine<DynamicRecord, DynamicLabelConsistencyReport> engine,
DiffRecordAccess records )
{
check( newRecord, engine, records );
}
@Override
public void checkReference( DynamicRecord record, DynamicRecord record2,
CheckerEngine<DynamicRecord, DynamicLabelConsistencyReport> engine,
RecordAccess records )
{
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeDynamicLabelOrphanChainStartCheck.java
|
4,141
|
{
@Override
public void checkReference( PropertyRecord record, PropertyKeyTokenRecord referred,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !referred.inUse() )
{
engine.report().keyNotInUse( block, referred );
}
}
@Override
public String toString()
{
return "PROPERTY_KEY";
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PropertyRecordCheck.java
|
4,142
|
class PropertyRecordCheck
implements RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport>
{
@Override
public void checkChange( PropertyRecord oldRecord, PropertyRecord newRecord,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
DiffRecordAccess records )
{
check( newRecord, engine, records );
if ( oldRecord.inUse() )
{
for ( PropertyField field : PropertyField.values() )
{
field.checkChange( oldRecord, newRecord, engine, records );
}
}
// Did this record belong to the marked owner before it changed? - does it belong to it now?
if ( oldRecord.inUse() )
{
OwnerChain.OLD.check( newRecord, engine, records );
}
if ( newRecord.inUse() )
{
OwnerChain.NEW.check( newRecord, engine, records );
}
// Previously referenced dynamic records should either still be referenced, or be deleted
Map<Long, PropertyBlock> prevStrings = new HashMap<>();
Map<Long, PropertyBlock> prevArrays = new HashMap<>();
for ( PropertyBlock block : oldRecord.getPropertyBlocks() )
{
PropertyType type = block.getType();
if ( type != null )
{
switch ( type )
{
case STRING:
prevStrings.put( block.getSingleValueLong(), block );
break;
case ARRAY:
prevArrays.put( block.getSingleValueLong(), block );
break;
}
}
}
for ( PropertyBlock block : newRecord.getPropertyBlocks() )
{
PropertyType type = block.getType();
if ( type != null )
{
switch ( type )
{
case STRING:
prevStrings.remove( block.getSingleValueLong() );
break;
case ARRAY:
prevArrays.remove( block.getSingleValueLong() );
break;
}
}
}
for ( PropertyBlock block : prevStrings.values() )
{
if ( records.changedString( block.getSingleValueLong() ) == null )
{
engine.report().stringUnreferencedButNotDeleted( block );
}
}
for ( PropertyBlock block : prevArrays.values() )
{
if ( records.changedArray( block.getSingleValueLong() ) == null )
{
engine.report().arrayUnreferencedButNotDeleted( block );
}
}
}
@Override
public void check( PropertyRecord record,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !record.inUse() )
{
return;
}
for ( PropertyField field : PropertyField.values() )
{
field.checkConsistency( record, engine, records );
}
for ( PropertyBlock block : record.getPropertyBlocks() )
{
checkDataBlock( block, engine, records );
}
}
private void checkDataBlock( PropertyBlock block,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( block.getKeyIndexId() < 0 )
{
engine.report().invalidPropertyKey( block );
}
else
{
engine.comparativeCheck( records.propertyKey( block.getKeyIndexId() ), propertyKey( block ) );
}
PropertyType type = block.forceGetType();
if ( type == null )
{
engine.report().invalidPropertyType( block );
}
else
{
switch ( type )
{
case STRING:
engine.comparativeCheck( records.string( block.getSingleValueLong() ),
DynamicReference.string( block ) );
break;
case ARRAY:
engine.comparativeCheck( records.array( block.getSingleValueLong() ), DynamicReference.array( block ) );
break;
default:
try
{
type.getValue( block, null );
}
catch ( Exception e )
{
engine.report().invalidPropertyValue( block );
}
break;
}
}
}
private enum PropertyField implements
RecordField<PropertyRecord, ConsistencyReport.PropertyConsistencyReport>,
ComparativeRecordChecker<PropertyRecord, PropertyRecord, ConsistencyReport.PropertyConsistencyReport>
{
PREV( Record.NO_PREVIOUS_PROPERTY )
{
@Override
public long valueFrom( PropertyRecord record )
{
return record.getPrevProp();
}
@Override
long otherReference( PropertyRecord record )
{
return record.getNextProp();
}
@Override
void notInUse( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property )
{
report.prevNotInUse( property );
}
@Override
void noBackReference( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property )
{
report.previousDoesNotReferenceBack( property );
}
@Override
void reportNotUpdated( ConsistencyReport.PropertyConsistencyReport report )
{
report.prevNotUpdated();
}
},
NEXT( Record.NO_NEXT_PROPERTY )
{
@Override
public long valueFrom( PropertyRecord record )
{
return record.getNextProp();
}
@Override
long otherReference( PropertyRecord record )
{
return record.getPrevProp();
}
@Override
void notInUse( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property )
{
report.nextNotInUse( property );
}
@Override
void noBackReference( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property )
{
report.nextDoesNotReferenceBack( property );
}
@Override
void reportNotUpdated( ConsistencyReport.PropertyConsistencyReport report )
{
report.nextNotUpdated();
}
};
private final Record NONE;
private PropertyField( Record none )
{
this.NONE = none;
}
abstract long otherReference( PropertyRecord record );
@Override
public void checkConsistency( PropertyRecord record,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !NONE.is( valueFrom( record ) ) )
{
engine.comparativeCheck( records.property( valueFrom( record ) ), this );
}
}
@Override
public void checkReference( PropertyRecord record, PropertyRecord referred,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !referred.inUse() )
{
notInUse( engine.report(), referred );
}
else
{
if ( otherReference( referred ) != record.getId() )
{
noBackReference( engine.report(), referred );
}
}
}
@Override
public void checkChange( PropertyRecord oldRecord, PropertyRecord newRecord,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
DiffRecordAccess records )
{
if ( !newRecord.inUse() || valueFrom( oldRecord ) != valueFrom( newRecord ) )
{
if ( !NONE.is( valueFrom( oldRecord ) )
&& records.changedProperty( valueFrom( oldRecord ) ) == null )
{
reportNotUpdated( engine.report() );
}
}
}
abstract void reportNotUpdated( ConsistencyReport.PropertyConsistencyReport report );
abstract void notInUse( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property );
abstract void noBackReference( ConsistencyReport.PropertyConsistencyReport report, PropertyRecord property );
}
private static ComparativeRecordChecker<PropertyRecord, PropertyKeyTokenRecord, ConsistencyReport.PropertyConsistencyReport>
propertyKey( final PropertyBlock block )
{
return new ComparativeRecordChecker<PropertyRecord, PropertyKeyTokenRecord, ConsistencyReport.PropertyConsistencyReport>()
{
@Override
public void checkReference( PropertyRecord record, PropertyKeyTokenRecord referred,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !referred.inUse() )
{
engine.report().keyNotInUse( block, referred );
}
}
@Override
public String toString()
{
return "PROPERTY_KEY";
}
};
}
private static abstract class DynamicReference implements
ComparativeRecordChecker<PropertyRecord, DynamicRecord, ConsistencyReport.PropertyConsistencyReport>
{
final PropertyBlock block;
private DynamicReference( PropertyBlock block )
{
this.block = block;
}
public static DynamicReference string( PropertyBlock block )
{
return new DynamicReference( block )
{
@Override
void notUsed( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.stringNotInUse( block, value );
}
@Override
void empty( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.stringEmpty( block, value );
}
};
}
public static DynamicReference array( PropertyBlock block )
{
return new DynamicReference( block )
{
@Override
void notUsed( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.arrayNotInUse( block, value );
}
@Override
void empty( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value )
{
report.arrayEmpty( block, value );
}
};
}
@Override
public void checkReference( PropertyRecord record, DynamicRecord referred,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !referred.inUse() )
{
notUsed( engine.report(), referred );
}
else
{
if ( referred.getLength() <= 0 )
{
empty( engine.report(), referred );
}
}
}
abstract void notUsed( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value );
abstract void empty( ConsistencyReport.PropertyConsistencyReport report, DynamicRecord value );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PropertyRecordCheck.java
|
4,143
|
public class PropertyKeyTokenRecordCheckTest extends
RecordCheckTestBase<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport, PropertyKeyTokenRecordCheck>
{
public PropertyKeyTokenRecordCheckTest()
{
super( new PropertyKeyTokenRecordCheck(), ConsistencyReport.PropertyKeyTokenConsistencyReport.class );
}
@Test
public void shouldNotReportAnythingForRecordNotInUse() throws Exception
{
// given
PropertyKeyTokenRecord key = notInUse( new PropertyKeyTokenRecord( 42 ) );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport report = check( key );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingForRecordThatDoesNotReferenceADynamicBlock() throws Exception
{
// given
PropertyKeyTokenRecord key = inUse( new PropertyKeyTokenRecord( 42 ) );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport report = check( key );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportDynamicBlockNotInUse() throws Exception
{
// given
PropertyKeyTokenRecord key = inUse( new PropertyKeyTokenRecord( 42 ) );
DynamicRecord name = addKeyName( notInUse( new DynamicRecord( 6 ) ) );
key.setNameId( (int) name.getId() );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport report = check( key );
// then
verify( report ).nameBlockNotInUse( name );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportEmptyName() throws Exception
{
// given
PropertyKeyTokenRecord key = inUse( new PropertyKeyTokenRecord( 42 ) );
DynamicRecord name = addKeyName( inUse( new DynamicRecord( 6 ) ) );
key.setNameId( (int) name.getId() );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport report = check( key );
// then
verify( report ).emptyName( name );
verifyNoMoreInteractions( report );
}
// change checking
@Test
public void shouldNotReportAnythingForConsistentlyChangedRecord() throws Exception
{
// given
PropertyKeyTokenRecord oldRecord = notInUse( new PropertyKeyTokenRecord( 42 ) );
PropertyKeyTokenRecord newRecord = inUse( new PropertyKeyTokenRecord( 42 ) );
DynamicRecord name = addKeyName( inUse( new DynamicRecord( 6 ) ) );
name.setData( new byte[1] );
newRecord.setNameId( (int) name.getId() );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport report = checkChange( oldRecord, newRecord );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportProblemsWithTheNewStateWhenCheckingChanges() throws Exception
{
// given
PropertyKeyTokenRecord oldRecord = notInUse( new PropertyKeyTokenRecord( 42 ) );
PropertyKeyTokenRecord newRecord = inUse( new PropertyKeyTokenRecord( 42 ) );
DynamicRecord name = addKeyName( notInUse( new DynamicRecord( 6 ) ) );
newRecord.setNameId( (int) name.getId() );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport report = checkChange( oldRecord, newRecord );
// then
verify( report ).nameBlockNotInUse( name );
verifyNoMoreInteractions( report );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_PropertyKeyTokenRecordCheckTest.java
|
4,144
|
class PropertyKeyTokenRecordCheck
extends TokenRecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport>
{
@Override
protected RecordReference<DynamicRecord> name( RecordAccess records, int id )
{
return records.propertyKeyName( id );
}
@Override
void nameNotInUse( ConsistencyReport.PropertyKeyTokenConsistencyReport report, DynamicRecord name )
{
report.nameBlockNotInUse( name );
}
@Override
void emptyName( ConsistencyReport.PropertyKeyTokenConsistencyReport report, DynamicRecord name )
{
report.emptyName( name );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PropertyKeyTokenRecordCheck.java
|
4,145
|
private class FirstProperty
implements RecordField<RECORD, REPORT>, ComparativeRecordChecker<RECORD, PropertyRecord, REPORT>
{
@Override
public void checkConsistency( RECORD record, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
if ( !Record.NO_NEXT_PROPERTY.is( record.getNextProp() ) )
{
engine.comparativeCheck( records.property( record.getNextProp() ), this );
}
}
@Override
public long valueFrom( RECORD record )
{
return record.getNextProp();
}
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
if ( !newRecord.inUse() || valueFrom( oldRecord ) != valueFrom( newRecord ) )
{
if ( !Record.NO_NEXT_PROPERTY.is( valueFrom( oldRecord ) )
&& records.changedProperty( valueFrom( oldRecord ) ) == null )
{
engine.report().propertyNotUpdated();
}
}
}
@Override
public void checkReference( RECORD record, PropertyRecord property, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
if ( !property.inUse() )
{
engine.report().propertyNotInUse( property );
}
else
{
if ( !Record.NO_PREVIOUS_PROPERTY.is( property.getPrevProp() ) )
{
engine.report().propertyNotFirstInChain( property );
}
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PrimitiveRecordCheck.java
|
4,146
|
{
@Override
public void checkReference( RECORD record, PrimitiveRecord other, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
if ( other instanceof NodeRecord )
{
engine.report().multipleOwners( (NodeRecord) other );
}
else if ( other instanceof RelationshipRecord )
{
engine.report().multipleOwners( (RelationshipRecord) other );
}
else if ( other instanceof NeoStoreRecord )
{
engine.report().multipleOwners( (NeoStoreRecord) other );
}
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PrimitiveRecordCheck.java
|
4,147
|
public abstract class PrimitiveRecordCheck
<RECORD extends PrimitiveRecord, REPORT extends ConsistencyReport.PrimitiveConsistencyReport>
implements RecordCheck<RECORD, REPORT>
{
private final RecordField<RECORD, REPORT>[] fields;
public final ComparativeRecordChecker<RECORD, PrimitiveRecord, REPORT> ownerCheck =
new ComparativeRecordChecker<RECORD, PrimitiveRecord, REPORT>()
{
@Override
public void checkReference( RECORD record, PrimitiveRecord other, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
if ( other instanceof NodeRecord )
{
engine.report().multipleOwners( (NodeRecord) other );
}
else if ( other instanceof RelationshipRecord )
{
engine.report().multipleOwners( (RelationshipRecord) other );
}
else if ( other instanceof NeoStoreRecord )
{
engine.report().multipleOwners( (NeoStoreRecord) other );
}
}
};
@SafeVarargs
PrimitiveRecordCheck( RecordField<RECORD, REPORT>... fields )
{
this.fields = Arrays.copyOf( fields, fields.length + 1 );
this.fields[fields.length] = new FirstProperty();
}
private class FirstProperty
implements RecordField<RECORD, REPORT>, ComparativeRecordChecker<RECORD, PropertyRecord, REPORT>
{
@Override
public void checkConsistency( RECORD record, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
if ( !Record.NO_NEXT_PROPERTY.is( record.getNextProp() ) )
{
engine.comparativeCheck( records.property( record.getNextProp() ), this );
}
}
@Override
public long valueFrom( RECORD record )
{
return record.getNextProp();
}
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
if ( !newRecord.inUse() || valueFrom( oldRecord ) != valueFrom( newRecord ) )
{
if ( !Record.NO_NEXT_PROPERTY.is( valueFrom( oldRecord ) )
&& records.changedProperty( valueFrom( oldRecord ) ) == null )
{
engine.report().propertyNotUpdated();
}
}
}
@Override
public void checkReference( RECORD record, PropertyRecord property, CheckerEngine<RECORD, REPORT> engine,
RecordAccess records )
{
if ( !property.inUse() )
{
engine.report().propertyNotInUse( property );
}
else
{
if ( !Record.NO_PREVIOUS_PROPERTY.is( property.getPrevProp() ) )
{
engine.report().propertyNotFirstInChain( property );
}
}
}
}
@Override
public void check( RECORD record, CheckerEngine<RECORD, REPORT> engine, RecordAccess records )
{
if ( !record.inUse() )
{
return;
}
for ( RecordField<RECORD, REPORT> field : fields )
{
field.checkConsistency( record, engine, records );
}
}
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
check( newRecord, engine, records );
if ( oldRecord.inUse() )
{
for ( RecordField<RECORD, REPORT> field : fields )
{
field.checkChange( oldRecord, newRecord, engine, records );
}
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_PrimitiveRecordCheck.java
|
4,148
|
{
@Override
public void checkReference( PropertyRecord record, PrimitiveRecord owner,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( !owner.inUse() || Record.NO_NEXT_PROPERTY.is( owner.getNextProp() ) )
{
wrongOwner( engine.report() );
}
else if ( owner.getNextProp() != record.getId() )
{
engine.comparativeCheck( property( (DiffRecordAccess) records, owner.getNextProp() ),
OwnerChain.this );
}
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_OwnerChain.java
|
4,149
|
NEW
{
@Override
RecordReference<PropertyRecord> property( DiffRecordAccess records, long id )
{
return records.property( id );
}
@Override
RecordReference<NodeRecord> node( DiffRecordAccess records, long id )
{
return records.node( id );
}
@Override
RecordReference<RelationshipRecord> relationship( DiffRecordAccess records, long id )
{
return records.relationship( id );
}
@Override
RecordReference<NeoStoreRecord> graph( DiffRecordAccess records )
{
return records.graph();
}
@Override
void wrongOwner( ConsistencyReport.PropertyConsistencyReport report )
{
report.ownerDoesNotReferenceBack();
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_OwnerChain.java
|
4,150
|
OLD
{
@Override
RecordReference<PropertyRecord> property( DiffRecordAccess records, long id )
{
return records.previousProperty( id );
}
@Override
RecordReference<NodeRecord> node( DiffRecordAccess records, long id )
{
return records.previousNode( id );
}
@Override
RecordReference<RelationshipRecord> relationship( DiffRecordAccess records, long id )
{
return records.previousRelationship( id );
}
@Override
RecordReference<NeoStoreRecord> graph( DiffRecordAccess records )
{
return records.previousGraph();
}
@Override
void wrongOwner( ConsistencyReport.PropertyConsistencyReport report )
{
report.changedForWrongOwner();
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_OwnerChain.java
|
4,151
|
public class NodeRecordCheckTest
extends RecordCheckTestBase<NodeRecord, ConsistencyReport.NodeConsistencyReport, NodeRecordCheck>
{
public NodeRecordCheckTest()
{
super( new NodeRecordCheck(), ConsistencyReport.NodeConsistencyReport.class );
}
@Test
public void shouldNotReportAnythingForNodeNotInUse() throws Exception
{
// given
NodeRecord node = notInUse( new NodeRecord( 42, 0, 0 ) );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingForNodeThatDoesNotReferenceOtherRecords() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, NONE, NONE ) );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingForNodeWithConsistentReferences() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, 7, 11 ) );
add( inUse( new RelationshipRecord( 7, 42, 0, 0 ) ) );
add( inUse( new PropertyRecord( 11 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportRelationshipNotInUse() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, 7, 11 ) );
RelationshipRecord relationship = add( notInUse( new RelationshipRecord( 7, 0, 0, 0 ) ) );
add( inUse( new PropertyRecord( 11 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).relationshipNotInUse( relationship );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportPropertyNotInUse() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, NONE, 11 ) );
PropertyRecord property = add( notInUse( new PropertyRecord( 11 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).propertyNotInUse( property );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportPropertyNotFirstInChain() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, NONE, 11 ) );
PropertyRecord property = add( inUse( new PropertyRecord( 11 ) ) );
property.setPrevProp( 6 );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).propertyNotFirstInChain( property );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportRelationshipForOtherNodes() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, 7, NONE ) );
RelationshipRecord relationship = add( inUse( new RelationshipRecord( 7, 1, 2, 0 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).relationshipForOtherNode( relationship );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportRelationshipNotFirstInSourceChain() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, 7, NONE ) );
RelationshipRecord relationship = add( inUse( new RelationshipRecord( 7, 42, 0, 0 ) ) );
relationship.setFirstPrevRel( 6 );
relationship.setSecondPrevRel( 8 );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).relationshipNotFirstInSourceChain( relationship );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportRelationshipNotFirstInTargetChain() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, 7, NONE ) );
RelationshipRecord relationship = add( inUse( new RelationshipRecord( 7, 0, 42, 0 ) ) );
relationship.setFirstPrevRel( 6 );
relationship.setSecondPrevRel( 8 );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).relationshipNotFirstInTargetChain( relationship );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportLoopRelationshipNotFirstInTargetAndSourceChains() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, 7, NONE ) );
RelationshipRecord relationship = add( inUse( new RelationshipRecord( 7, 42, 42, 0 ) ) );
relationship.setFirstPrevRel( 8 );
relationship.setSecondPrevRel( 8 );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).relationshipNotFirstInSourceChain( relationship );
verify( report ).relationshipNotFirstInTargetChain( relationship );
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportLabelNotInUse() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, NONE, NONE ) );
new InlineNodeLabels( node.getLabelField(), node ).add( 1, null );
LabelTokenRecord labelRecordNotInUse = notInUse( new LabelTokenRecord( 1 ) );
add( labelRecordNotInUse );
add( node );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).labelNotInUse( labelRecordNotInUse );
}
@Test
public void shouldReportDynamicLabelsNotInUse() throws Exception
{
// given
long[] labelIds = createLabels( 100 );
LabelTokenRecord labelRecordNotInUse = notInUse( new LabelTokenRecord( labelIds.length ) );
add( labelRecordNotInUse );
NodeRecord node = inUse( new NodeRecord( 42, NONE, NONE ) );
add( node );
DynamicRecord labelsRecord1 = inUse( array( new DynamicRecord( 1 ) ) );
DynamicRecord labelsRecord2 = inUse( array( new DynamicRecord( 2 ) ) );
Collection<DynamicRecord> labelRecords = asList( labelsRecord1, labelsRecord2 );
labelIds[12] = labelIds.length;
DynamicArrayStore.allocateFromNumbers( labelIds, labelRecords.iterator(), new PreAllocatedRecords( 52 ) );
assertDynamicRecordChain( labelsRecord1, labelsRecord2 );
node.setLabelField( DynamicNodeLabels.dynamicPointer( labelRecords ), labelRecords );
addNodeDynamicLabels( labelsRecord1 );
addNodeDynamicLabels( labelsRecord2 );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).labelNotInUse( labelRecordNotInUse );
}
@Test
public void shouldReportDuplicateLabels() throws Exception
{
// given
NodeRecord node = inUse( new NodeRecord( 42, NONE, NONE ) );
new InlineNodeLabels( node.getLabelField(), node ).put( new long[]{1, 2, 1}, null );
LabelTokenRecord label1 = inUse( new LabelTokenRecord( 1 ) );
LabelTokenRecord label2 = inUse( new LabelTokenRecord( 2 ) );
add( label1 );
add( label2 );
add( node );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).labelDuplicate( 1 );
}
@Test
public void shouldReportDuplicateDynamicLabels() throws Exception
{
// given
long[] labelIds = createLabels( 100 );
NodeRecord node = inUse( new NodeRecord( 42, NONE, NONE ) );
add( node );
DynamicRecord labelsRecord1 = inUse( array( new DynamicRecord( 1 ) ) );
DynamicRecord labelsRecord2 = inUse( array( new DynamicRecord( 2 ) ) );
Collection<DynamicRecord> labelRecords = asList( labelsRecord1, labelsRecord2 );
labelIds[12] = 11;
DynamicArrayStore.allocateFromNumbers( labelIds, labelRecords.iterator(), new PreAllocatedRecords( 52 ) );
assertDynamicRecordChain( labelsRecord1, labelsRecord2 );
node.setLabelField( DynamicNodeLabels.dynamicPointer( labelRecords ), labelRecords );
addNodeDynamicLabels( labelsRecord1 );
addNodeDynamicLabels( labelsRecord2 );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).labelDuplicate( 11 );
}
@Test
public void shouldDynamicLabelRecordsNotInUse() throws Exception
{
// given
long[] labelIds = createLabels( 100 );
NodeRecord node = inUse( new NodeRecord( 42, NONE, NONE ) );
add( node );
DynamicRecord labelsRecord1 = notInUse( array( new DynamicRecord( 1 ) ) );
DynamicRecord labelsRecord2 = notInUse( array( new DynamicRecord( 2 ) ) );
Collection<DynamicRecord> labelRecords = asList( labelsRecord1, labelsRecord2 );
DynamicArrayStore.allocateFromNumbers( labelIds, labelRecords.iterator(), new PreAllocatedRecords( 52 ) );
assertDynamicRecordChain( labelsRecord1, labelsRecord2 );
node.setLabelField( DynamicNodeLabels.dynamicPointer( labelRecords ), labelRecords );
addNodeDynamicLabels( labelsRecord1 );
addNodeDynamicLabels( labelsRecord2 );
// when
ConsistencyReport.NodeConsistencyReport report = check( node );
// then
verify( report ).dynamicLabelRecordNotInUse( labelsRecord1 );
verify( report ).dynamicLabelRecordNotInUse( labelsRecord2 );
}
@Test
public void shouldNotReportAnythingForConsistentlyChangedNode() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, 11, 1 ) );
NodeRecord newNode = inUse( new NodeRecord( 42, 12, 2 ) );
addChange( inUse( new RelationshipRecord( 11, 42, 0, 0 ) ),
notInUse( new RelationshipRecord( 11, 0, 0, 0 ) ) );
addChange( notInUse( new RelationshipRecord( 12, 0, 0, 0 ) ),
inUse( new RelationshipRecord( 12, 42, 0, 0 ) ) );
addChange( inUse( new PropertyRecord( 1 ) ),
notInUse( new PropertyRecord( 1 ) ) );
addChange( notInUse( new PropertyRecord( 2 ) ),
inUse( new PropertyRecord( 2 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportProblemsWithTheNewStateWhenCheckingChanges() throws Exception
{
// given
NodeRecord oldNode = notInUse( new NodeRecord( 42, 0, 0 ) );
NodeRecord newNode = inUse( new NodeRecord( 42, 1, 2 ) );
RelationshipRecord relationship = add( notInUse( new RelationshipRecord( 1, 0, 0, 0 ) ) );
PropertyRecord property = add( notInUse( new PropertyRecord( 2 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verify( report ).relationshipNotInUse( relationship );
verify( report ).propertyNotInUse( property );
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingWhenAddingAnInitialProperty() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, NONE, NONE ) );
NodeRecord newNode = inUse( new NodeRecord( 42, NONE, 10 ) );
addChange( notInUse( new PropertyRecord( 10 ) ), inUse( new PropertyRecord( 10 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingWhenChangingProperty() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, NONE, 10 ) );
NodeRecord newNode = inUse( new NodeRecord( 42, NONE, 11 ) );
PropertyRecord oldProp = addChange( inUse( new PropertyRecord( 10 ) ),
inUse( new PropertyRecord( 10 ) ) );
PropertyRecord newProp = addChange( notInUse( new PropertyRecord( 11 ) ),
inUse( new PropertyRecord( 11 ) ) );
oldProp.setPrevProp( newProp.getId() );
newProp.setNextProp( oldProp.getId() );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingWhenAddingAnInitialRelationship() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, NONE, NONE ) );
NodeRecord newNode = inUse( new NodeRecord( 42, 10, NONE ) );
addChange( notInUse( new RelationshipRecord( 10, 0, 0, 0 ) ),
inUse( new RelationshipRecord( 10, 42, 1, 0 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldNotReportAnythingWhenChangingRelationship() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, 9, NONE ) );
NodeRecord newNode = inUse( new NodeRecord( 42, 10, NONE ) );
RelationshipRecord rel1 = addChange( inUse( new RelationshipRecord( 9, 42, 0, 0 ) ),
inUse( new RelationshipRecord( 9, 42, 0, 0 ) ) );
RelationshipRecord rel2 = addChange( notInUse( new RelationshipRecord( 10, 0, 0, 0 ) ),
inUse( new RelationshipRecord( 10, 42, 1, 0 ) ) );
rel1.setFirstPrevRel( rel2.getId() );
rel2.setFirstNextRel( rel1.getId() );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportPropertyChainReplacedButNotUpdated() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, NONE, 1 ) );
NodeRecord newNode = inUse( new NodeRecord( 42, NONE, 2 ) );
addChange( notInUse( new PropertyRecord( 2 ) ),
inUse( new PropertyRecord( 2 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verify( report ).propertyNotUpdated();
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportRelationshipChainReplacedButNotUpdated() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, 1, NONE ) );
NodeRecord newNode = inUse( new NodeRecord( 42, 2, NONE ) );
addChange( notInUse( new RelationshipRecord( 2, 0, 0, 0 ) ),
inUse( new RelationshipRecord( 2, 42, 0, 0 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verify( report ).relationshipNotUpdated();
verifyNoMoreInteractions( report );
}
@Test
public void shouldReportDeletedButReferencesNotUpdated() throws Exception
{
// given
NodeRecord oldNode = inUse( new NodeRecord( 42, 1, 10 ) );
NodeRecord newNode = notInUse( new NodeRecord( 42, 1, 10 ) );
// when
ConsistencyReport.NodeConsistencyReport report = checkChange( oldNode, newNode );
// then
verify( report ).relationshipNotUpdated();
verify( report ).propertyNotUpdated();
verifyNoMoreInteractions( report );
}
private long[] createLabels( int labelCount )
{
long[] labelIds = new long[labelCount];
for ( int i = 0; i < labelIds.length; i++ )
{
labelIds[i] = i;
add( inUse( new LabelTokenRecord( i ) ) );
}
return labelIds;
}
private void assertDynamicRecordChain( DynamicRecord... records )
{
if ( records.length > 0)
{
for ( int i = 1; i < records.length; i++ )
{
assertEquals( records[i].getId(), records[i - 1].getNextBlock() );
}
assertTrue( Record.NO_NEXT_BLOCK.is( records[records.length - 1].getNextBlock() ) );
}
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_NodeRecordCheckTest.java
|
4,152
|
NEXT_REL
{
@Override
public void checkConsistency( NodeRecord node,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
if ( !Record.NO_NEXT_RELATIONSHIP.is( node.getNextRel() ) )
{
engine.comparativeCheck( records.relationship( node.getNextRel() ), this );
}
}
@Override
public void checkReference( NodeRecord node, RelationshipRecord relationship,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
if ( !relationship.inUse() )
{
engine.report().relationshipNotInUse( relationship );
}
else
{
NodeField selectedField = NodeField.select( relationship, node );
if ( selectedField == null )
{
engine.report().relationshipForOtherNode( relationship );
}
else
{
NodeField[] fields;
if ( relationship.getFirstNode() == relationship.getSecondNode() )
{ // this relationship is a loop, report both inconsistencies
fields = NodeField.values();
}
else
{
fields = new NodeField[]{selectedField};
}
for ( NodeField field : fields )
{
if ( !Record.NO_NEXT_RELATIONSHIP.is( field.prev( relationship ) ) )
{
field.notFirstInChain( engine.report(), relationship );
}
}
}
}
}
@Override
public void checkChange( NodeRecord oldRecord, NodeRecord newRecord,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
DiffRecordAccess records )
{
if ( !newRecord.inUse() || valueFrom( oldRecord ) != valueFrom( newRecord ) )
{
if ( !Record.NO_NEXT_RELATIONSHIP.is( valueFrom( oldRecord ) )
&& records.changedRelationship( valueFrom( oldRecord ) ) == null )
{
engine.report().relationshipNotUpdated();
}
}
}
@Override
public long valueFrom( NodeRecord record )
{
return record.getNextRel();
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeRecordCheck.java
|
4,153
|
class NodeLabelsComparativeRecordChecker implements
LabelChainWalker.Validator<NodeRecord, ConsistencyReport.NodeConsistencyReport>
{
@Override
public void onRecordNotInUse( DynamicRecord dynamicRecord, CheckerEngine<NodeRecord,
ConsistencyReport.NodeConsistencyReport> engine )
{
engine.report().dynamicLabelRecordNotInUse( dynamicRecord );
}
@Override
public void onRecordChainCycle( DynamicRecord record, CheckerEngine<NodeRecord, ConsistencyReport
.NodeConsistencyReport> engine )
{
engine.report().dynamicRecordChainCycle( record );
}
@Override
public void onWellFormedChain( long[] labelIds, CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine, RecordAccess records )
{
validateLabelIds( labelIds, engine, records );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeRecordCheck.java
|
4,154
|
LABELS
{
@Override
public void checkConsistency( NodeRecord node,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
NodeLabels nodeLabels = NodeLabelsField.parseLabelsField( node );
if ( nodeLabels instanceof DynamicNodeLabels )
{
DynamicNodeLabels dynamicNodeLabels = (DynamicNodeLabels) nodeLabels;
long firstRecordId = dynamicNodeLabels.getFirstDynamicRecordId();
RecordReference<DynamicRecord> firstRecordReference = records.nodeLabels( firstRecordId );
engine.comparativeCheck( firstRecordReference,
new LabelChainWalker<NodeRecord, ConsistencyReport.NodeConsistencyReport>(
new NodeLabelsComparativeRecordChecker() ) );
}
else
{
validateLabelIds( nodeLabels.get( null ), engine, records );
}
}
private void validateLabelIds( long[] labelIds,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
for ( long labelId : labelIds )
{
engine.comparativeCheck( records.label( (int) labelId ), this );
}
sort( labelIds );
for ( int i = 1; i < labelIds.length; i++ )
{
if ( labelIds[i - 1] == labelIds[i] )
{
engine.report().labelDuplicate( labelIds[i] );
}
}
}
@Override
public void checkReference( NodeRecord node, LabelTokenRecord labelTokenRecord,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
if ( !labelTokenRecord.inUse() )
{
engine.report().labelNotInUse( labelTokenRecord );
}
}
@Override
public void checkChange( NodeRecord oldRecord, NodeRecord newRecord,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
DiffRecordAccess records )
{
// nothing to check: no back references from labels to nodes
}
@Override
public long valueFrom( NodeRecord record )
{
return record.getLabelField();
}
class NodeLabelsComparativeRecordChecker implements
LabelChainWalker.Validator<NodeRecord, ConsistencyReport.NodeConsistencyReport>
{
@Override
public void onRecordNotInUse( DynamicRecord dynamicRecord, CheckerEngine<NodeRecord,
ConsistencyReport.NodeConsistencyReport> engine )
{
engine.report().dynamicLabelRecordNotInUse( dynamicRecord );
}
@Override
public void onRecordChainCycle( DynamicRecord record, CheckerEngine<NodeRecord, ConsistencyReport
.NodeConsistencyReport> engine )
{
engine.report().dynamicRecordChainCycle( record );
}
@Override
public void onWellFormedChain( long[] labelIds, CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine, RecordAccess records )
{
validateLabelIds( labelIds, engine, records );
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeRecordCheck.java
|
4,155
|
class NodeRecordCheck extends PrimitiveRecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport>
{
NodeRecordCheck()
{
super( RelationshipField.NEXT_REL, LabelsField.LABELS );
}
private enum RelationshipField implements RecordField<NodeRecord, ConsistencyReport.NodeConsistencyReport>,
ComparativeRecordChecker<NodeRecord, RelationshipRecord, ConsistencyReport.NodeConsistencyReport>
{
NEXT_REL
{
@Override
public void checkConsistency( NodeRecord node,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
if ( !Record.NO_NEXT_RELATIONSHIP.is( node.getNextRel() ) )
{
engine.comparativeCheck( records.relationship( node.getNextRel() ), this );
}
}
@Override
public void checkReference( NodeRecord node, RelationshipRecord relationship,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
if ( !relationship.inUse() )
{
engine.report().relationshipNotInUse( relationship );
}
else
{
NodeField selectedField = NodeField.select( relationship, node );
if ( selectedField == null )
{
engine.report().relationshipForOtherNode( relationship );
}
else
{
NodeField[] fields;
if ( relationship.getFirstNode() == relationship.getSecondNode() )
{ // this relationship is a loop, report both inconsistencies
fields = NodeField.values();
}
else
{
fields = new NodeField[]{selectedField};
}
for ( NodeField field : fields )
{
if ( !Record.NO_NEXT_RELATIONSHIP.is( field.prev( relationship ) ) )
{
field.notFirstInChain( engine.report(), relationship );
}
}
}
}
}
@Override
public void checkChange( NodeRecord oldRecord, NodeRecord newRecord,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
DiffRecordAccess records )
{
if ( !newRecord.inUse() || valueFrom( oldRecord ) != valueFrom( newRecord ) )
{
if ( !Record.NO_NEXT_RELATIONSHIP.is( valueFrom( oldRecord ) )
&& records.changedRelationship( valueFrom( oldRecord ) ) == null )
{
engine.report().relationshipNotUpdated();
}
}
}
@Override
public long valueFrom( NodeRecord record )
{
return record.getNextRel();
}
}
}
private enum LabelsField implements RecordField<NodeRecord, ConsistencyReport.NodeConsistencyReport>,
ComparativeRecordChecker<NodeRecord, LabelTokenRecord, ConsistencyReport.NodeConsistencyReport>
{
LABELS
{
@Override
public void checkConsistency( NodeRecord node,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
NodeLabels nodeLabels = NodeLabelsField.parseLabelsField( node );
if ( nodeLabels instanceof DynamicNodeLabels )
{
DynamicNodeLabels dynamicNodeLabels = (DynamicNodeLabels) nodeLabels;
long firstRecordId = dynamicNodeLabels.getFirstDynamicRecordId();
RecordReference<DynamicRecord> firstRecordReference = records.nodeLabels( firstRecordId );
engine.comparativeCheck( firstRecordReference,
new LabelChainWalker<NodeRecord, ConsistencyReport.NodeConsistencyReport>(
new NodeLabelsComparativeRecordChecker() ) );
}
else
{
validateLabelIds( nodeLabels.get( null ), engine, records );
}
}
private void validateLabelIds( long[] labelIds,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
for ( long labelId : labelIds )
{
engine.comparativeCheck( records.label( (int) labelId ), this );
}
sort( labelIds );
for ( int i = 1; i < labelIds.length; i++ )
{
if ( labelIds[i - 1] == labelIds[i] )
{
engine.report().labelDuplicate( labelIds[i] );
}
}
}
@Override
public void checkReference( NodeRecord node, LabelTokenRecord labelTokenRecord,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
RecordAccess records )
{
if ( !labelTokenRecord.inUse() )
{
engine.report().labelNotInUse( labelTokenRecord );
}
}
@Override
public void checkChange( NodeRecord oldRecord, NodeRecord newRecord,
CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine,
DiffRecordAccess records )
{
// nothing to check: no back references from labels to nodes
}
@Override
public long valueFrom( NodeRecord record )
{
return record.getLabelField();
}
class NodeLabelsComparativeRecordChecker implements
LabelChainWalker.Validator<NodeRecord, ConsistencyReport.NodeConsistencyReport>
{
@Override
public void onRecordNotInUse( DynamicRecord dynamicRecord, CheckerEngine<NodeRecord,
ConsistencyReport.NodeConsistencyReport> engine )
{
engine.report().dynamicLabelRecordNotInUse( dynamicRecord );
}
@Override
public void onRecordChainCycle( DynamicRecord record, CheckerEngine<NodeRecord, ConsistencyReport
.NodeConsistencyReport> engine )
{
engine.report().dynamicRecordChainCycle( record );
}
@Override
public void onWellFormedChain( long[] labelIds, CheckerEngine<NodeRecord, ConsistencyReport.NodeConsistencyReport> engine, RecordAccess records )
{
validateLabelIds( labelIds, engine, records );
}
}
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeRecordCheck.java
|
4,156
|
TARGET
{
@Override
public long valueFrom( RelationshipRecord relationship )
{
return relationship.getSecondNode();
}
@Override
public long prev( RelationshipRecord relationship )
{
return relationship.getSecondPrevRel();
}
@Override
public long next( RelationshipRecord relationship )
{
return relationship.getSecondNextRel();
}
@Override
void illegalNode( ConsistencyReport.RelationshipConsistencyReport report )
{
report.illegalTargetNode();
}
@Override
void nodeNotInUse( ConsistencyReport.RelationshipConsistencyReport report, NodeRecord node )
{
report.targetNodeNotInUse( node );
}
@Override
void noBackReference( ConsistencyReport.RelationshipConsistencyReport report, NodeRecord node )
{
report.targetNodeDoesNotReferenceBack( node );
}
@Override
void noChain( ConsistencyReport.RelationshipConsistencyReport report, NodeRecord node )
{
report.targetNodeHasNoRelationships( node );
}
@Override
void notFirstInChain( ConsistencyReport.NodeConsistencyReport report, RelationshipRecord relationship )
{
report.relationshipNotFirstInTargetChain( relationship );
}
@Override
void notUpdated( ConsistencyReport.RelationshipConsistencyReport report )
{
report.targetNodeNotUpdated();
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeField.java
|
4,157
|
SOURCE
{
@Override
public long valueFrom( RelationshipRecord relationship )
{
return relationship.getFirstNode();
}
@Override
public long prev( RelationshipRecord relationship )
{
return relationship.getFirstPrevRel();
}
@Override
public long next( RelationshipRecord relationship )
{
return relationship.getFirstNextRel();
}
@Override
void illegalNode( ConsistencyReport.RelationshipConsistencyReport report )
{
report.illegalSourceNode();
}
@Override
void nodeNotInUse( ConsistencyReport.RelationshipConsistencyReport report, NodeRecord node )
{
report.sourceNodeNotInUse( node );
}
@Override
void noBackReference( ConsistencyReport.RelationshipConsistencyReport report, NodeRecord node )
{
report.sourceNodeDoesNotReferenceBack( node );
}
@Override
void noChain( ConsistencyReport.RelationshipConsistencyReport report, NodeRecord node )
{
report.sourceNodeHasNoRelationships( node );
}
@Override
void notFirstInChain( ConsistencyReport.NodeConsistencyReport report, RelationshipRecord relationship )
{
report.relationshipNotFirstInSourceChain( relationship );
}
@Override
void notUpdated( ConsistencyReport.RelationshipConsistencyReport report )
{
report.sourceNodeNotUpdated();
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeField.java
|
4,158
|
public class NodeDynamicLabelOrphanChainStartCheckTest
extends RecordCheckTestBase<DynamicRecord, DynamicLabelConsistencyReport, NodeDynamicLabelOrphanChainStartCheck>
{
public static final PreAllocatedRecords RECORD_ALLOCATOR = new PreAllocatedRecords( 66 );
public NodeDynamicLabelOrphanChainStartCheckTest()
{
super( new NodeDynamicLabelOrphanChainStartCheck(), DynamicLabelConsistencyReport.class );
}
@Test @Ignore("2013-07-17 Revisit once we store sorted label ids")
public void shouldReportOrphanRecordsThatAreNotFirst() throws Exception
{
// given
DynamicRecord record0 = addNodeDynamicLabels( inUse( new DynamicRecord( 0 ) ) );
DynamicRecord record1 = addNodeDynamicLabels( inUse( new DynamicRecord( 1 ) ) );
DynamicRecord record2 = addNodeDynamicLabels( inUse( new DynamicRecord( 2 ) ) );
long[] longs = new long[130];
for ( int i = 0; i < longs.length; i++ )
{
longs[i] = i;
}
allocateFromNumbers( longs, iterator( record0, record1, record2 ), RECORD_ALLOCATOR );
record0.setInUse( false );
// when
DynamicLabelConsistencyReport report = check( record1 );
// then
verify( report ).orphanDynamicLabelRecord();
}
@Test
public void shouldReportMissingOwnerId() throws Exception
{
// given
DynamicRecord nodeDynamicLabelRecord = inUse( new DynamicRecord( 0 ) ) ;
allocateFromNumbers( new long[] { }, iterator( nodeDynamicLabelRecord ), RECORD_ALLOCATOR );
// when
DynamicLabelConsistencyReport report = check( nodeDynamicLabelRecord );
// then
verify( report ).orphanDynamicLabelRecord();
}
@Test
public void shouldReportOwningNodeRecordNotInUse() throws Exception
{
// given
NodeRecord nodeRecord = notInUse( new NodeRecord( 12l, -1, -1 ) );
add( nodeRecord );
DynamicRecord nodeDynamicLabelRecord = inUse( new DynamicRecord( 0 ) );
allocateFromNumbers( new long[]{12l}, iterator( nodeDynamicLabelRecord ), RECORD_ALLOCATOR );
// when
DynamicLabelConsistencyReport report = check( nodeDynamicLabelRecord );
// then
verify( report ).orphanDynamicLabelRecordDueToInvalidOwner( nodeRecord );
}
@Test
public void shouldReportOwningNodeRecordNotPointingBack() throws Exception
{
// given
long nodeId = 12l;
Collection<DynamicRecord> validLabelRecords =
allocateFromNumbers( new long[] {nodeId}, iterator( inUse( new DynamicRecord( 0 ) ) ), RECORD_ALLOCATOR );
Collection<DynamicRecord> fakePointedToRecords =
allocateFromNumbers( new long[] {nodeId}, iterator( inUse( new DynamicRecord( 1 ) ) ), RECORD_ALLOCATOR );
NodeRecord nodeRecord = inUse( new NodeRecord( nodeId, -1, -1 ) );
nodeRecord.setLabelField( dynamicPointer( fakePointedToRecords ), fakePointedToRecords );
add( nodeRecord );
// when
DynamicLabelConsistencyReport report = check( single( validLabelRecords.iterator() ) );
// then
verify( report ).orphanDynamicLabelRecordDueToInvalidOwner( nodeRecord );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_NodeDynamicLabelOrphanChainStartCheckTest.java
|
4,159
|
{
@Override
public void checkReference( DynamicRecord record, NodeRecord nodeRecord,
CheckerEngine<DynamicRecord, DynamicLabelConsistencyReport> engine,
RecordAccess records )
{
if ( ! nodeRecord.inUse() )
{
// if this node record is not in use it is not a valid owner
engine.report().orphanDynamicLabelRecordDueToInvalidOwner( nodeRecord );
}
else
{
// if this node record is in use but doesn't point to the dynamic label record
// that label record has an invalid owner
Long dynamicLabelRecordId = fieldDynamicLabelRecordId( nodeRecord.getLabelField() );
long recordId = record.getLongId();
if ( dynamicLabelRecordId == null || dynamicLabelRecordId.longValue() != recordId )
{
engine.report().orphanDynamicLabelRecordDueToInvalidOwner( nodeRecord );
}
}
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_NodeDynamicLabelOrphanChainStartCheck.java
|
4,160
|
private static class LoggingReference<T extends AbstractBaseRecord> implements RecordReference<T>
{
private final RecordReference<T> reference;
private final InvocationLog log;
LoggingReference( RecordReference<T> reference, InvocationLog log )
{
this.reference = reference;
this.log = log;
}
@SuppressWarnings("unchecked")
@Override
public void dispatch( PendingReferenceCheck<T> reporter )
{
reference.dispatch( mock( (Class<PendingReferenceCheck<T>>) reporter.getClass(),
withSettings().spiedInstance( reporter )
.defaultAnswer( new ReporterSpy<>( reference, reporter, log ) ) ) );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_ExecutionOrderIntegrationTest.java
|
4,161
|
private static class ReporterSpy<T extends AbstractBaseRecord> implements Answer<Object>
{
private final RecordReference<T> reference;
private final PendingReferenceCheck<T> reporter;
private final InvocationLog log;
public ReporterSpy( RecordReference<T> reference, PendingReferenceCheck<T> reporter, InvocationLog log )
{
this.reference = reference;
this.reporter = reporter;
this.log = log;
}
@Override
public Object answer( InvocationOnMock invocation ) throws Throwable
{
if ( !(reference instanceof RecordReference.SkippingReference<?>) )
{
log.log( reporter, invocation );
}
return invocation.callRealMethod();
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_ExecutionOrderIntegrationTest.java
|
4,162
|
public class FullCheck
{
private final boolean checkPropertyOwners;
private final boolean checkLabelScanStore;
private final boolean checkIndexes;
private final TaskExecutionOrder order;
private final ProgressMonitorFactory progressFactory;
private final Long totalMappedMemory;
public FullCheck( Config tuningConfiguration, ProgressMonitorFactory progressFactory )
{
this.checkPropertyOwners = tuningConfiguration.get( ConsistencyCheckSettings.consistency_check_property_owners );
this.checkLabelScanStore = tuningConfiguration.get( ConsistencyCheckSettings.consistency_check_label_scan_store );
this.checkIndexes = tuningConfiguration.get( ConsistencyCheckSettings.consistency_check_indexes );
this.order = tuningConfiguration.get( ConsistencyCheckSettings.consistency_check_execution_order );
this.totalMappedMemory = tuningConfiguration.get( GraphDatabaseSettings.all_stores_total_mapped_memory_size );
this.progressFactory = progressFactory;
}
public ConsistencySummaryStatistics execute( DirectStoreAccess stores, StringLogger logger )
throws ConsistencyCheckIncompleteException
{
ConsistencySummaryStatistics summary = new ConsistencySummaryStatistics();
InconsistencyReport report = new InconsistencyReport( new InconsistencyMessageLogger( logger ), summary );
OwnerCheck ownerCheck = new OwnerCheck( checkPropertyOwners );
execute( stores, ownerCheck, recordAccess( stores.nativeStores() ), report );
ownerCheck.scanForOrphanChains( progressFactory );
if ( !summary.isConsistent() )
{
logger.logMessage( "Inconsistencies found: " + summary );
}
return summary;
}
void execute( final DirectStoreAccess directStoreAccess, CheckDecorator decorator, final DiffRecordAccess recordAccess,
final InconsistencyReport report )
throws ConsistencyCheckIncompleteException
{
final ConsistencyReporter reporter = new ConsistencyReporter( recordAccess, report );
StoreProcessor processEverything = new StoreProcessor( decorator, reporter );
ProgressMonitorFactory.MultiPartBuilder progress = progressFactory.multipleParts( "Full consistency check" );
final StoreAccess nativeStores = directStoreAccess.nativeStores();
try ( IndexAccessors indexes = new IndexAccessors( directStoreAccess.indexes(), nativeStores.getSchemaStore() ) )
{
MultiPassStore.Factory multiPass = new MultiPassStore.Factory(
decorator, totalMappedMemory, nativeStores, recordAccess, report );
List<StoppableRunnable> tasks = new ConsistencyCheckTasks( progress, order, processEverything ).createTasks(
nativeStores,
directStoreAccess.labelScanStore(),
indexes,
multiPass,
reporter,
checkLabelScanStore,
checkIndexes
);
order.execute( tasks, progress.build() );
}
catch ( Exception e )
{
throw new ConsistencyCheckIncompleteException( e );
}
}
static DiffRecordAccess recordAccess( StoreAccess store )
{
return new CacheSmallStoresRecordAccess(
new DirectRecordAccess( store ),
readAllRecords( PropertyKeyTokenRecord.class, store.getPropertyKeyTokenStore() ),
readAllRecords( RelationshipTypeTokenRecord.class, store.getRelationshipTypeTokenStore() ),
readAllRecords( LabelTokenRecord.class, store.getLabelTokenStore() ) );
}
private static <T extends AbstractBaseRecord> T[] readAllRecords( Class<T> type, RecordStore<T> store )
{
@SuppressWarnings("unchecked")
T[] records = (T[]) Array.newInstance( type, (int) store.getHighId() );
for ( int i = 0; i < records.length; i++ )
{
records[i] = store.forceGetRecord( i );
}
return records;
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_FullCheck.java
|
4,163
|
public class OwnerCheckTest
{
@Test
public void shouldNotDecorateCheckerWhenInactive() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( false );
PrimitiveRecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> checker = dummyNodeCheck();
// when
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> decorated =
decorator.decorateNodeChecker( checker );
// then
assertSame( checker, decorated );
}
@Test
public void shouldNotReportAnythingForNodesWithDifferentPropertyChains() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeChecker =
decorator.decorateNodeChecker( dummyNodeCheck() );
RecordAccessStub records = new RecordAccessStub();
NodeRecord node1 = records.add( inUse( new NodeRecord( 1, NONE, 7 ) ) );
NodeRecord node2 = records.add( inUse( new NodeRecord( 2, NONE, 8 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report1 =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node1, records );
ConsistencyReport.NodeConsistencyReport report2 =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node2, records );
// then
verifyZeroInteractions( report1 );
verifyZeroInteractions( report2 );
}
@Test
public void shouldNotReportAnythingForNodesNotInUse() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeChecker =
decorator.decorateNodeChecker( dummyNodeCheck() );
RecordAccessStub records = new RecordAccessStub();
NodeRecord node1 = records.add( notInUse( new NodeRecord( 1, NONE, 6 ) ) );
NodeRecord node2 = records.add( notInUse( new NodeRecord( 2, NONE, 6 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report1 =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node1, records );
ConsistencyReport.NodeConsistencyReport report2 =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node2, records );
// then
verifyZeroInteractions( report1 );
verifyZeroInteractions( report2 );
}
@Test
public void shouldNotReportAnythingForRelationshipsWithDifferentPropertyChains() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> relationshipChecker =
decorator.decorateRelationshipChecker( dummyRelationshipChecker() );
RecordAccessStub records = new RecordAccessStub();
RelationshipRecord relationship1 = records.add( inUse( new RelationshipRecord( 1, 0, 1, 0 ) ) );
relationship1.setNextProp( 7 );
RelationshipRecord relationship2 = records.add( inUse( new RelationshipRecord( 2, 0, 1, 0 ) ) );
relationship2.setNextProp( 8 );
// when
ConsistencyReport.RelationshipConsistencyReport report1 =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship1, records );
ConsistencyReport.RelationshipConsistencyReport report2 =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship2, records );
// then
verifyZeroInteractions( report1 );
verifyZeroInteractions( report2 );
}
@Test
public void shouldReportTwoNodesWithSamePropertyChain() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeChecker =
decorator.decorateNodeChecker( dummyNodeCheck() );
RecordAccessStub records = new RecordAccessStub();
NodeRecord node1 = records.add( inUse( new NodeRecord( 1, NONE, 7 ) ) );
NodeRecord node2 = records.add( inUse( new NodeRecord( 2, NONE, 7 ) ) );
// when
ConsistencyReport.NodeConsistencyReport report1 =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node1, records );
ConsistencyReport.NodeConsistencyReport report2 =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node2, records );
// then
verifyZeroInteractions( report1 );
verify( report2 ).multipleOwners( node1 );
}
@Test
public void shouldReportTwoRelationshipsWithSamePropertyChain() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> relationshipChecker =
decorator.decorateRelationshipChecker( dummyRelationshipChecker() );
RecordAccessStub records = new RecordAccessStub();
RelationshipRecord relationship1 = records.add( inUse( new RelationshipRecord( 1, 0, 1, 0 ) ) );
relationship1.setNextProp( 7 );
RelationshipRecord relationship2 = records.add( inUse( new RelationshipRecord( 2, 0, 1, 0 ) ) );
relationship2.setNextProp( relationship1.getNextProp() );
// when
ConsistencyReport.RelationshipConsistencyReport report1 =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship1, records );
ConsistencyReport.RelationshipConsistencyReport report2 =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship2, records );
// then
verifyZeroInteractions( report1 );
verify( report2 ).multipleOwners( relationship1 );
}
@Test
public void shouldReportRelationshipWithSamePropertyChainAsNode() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeChecker =
decorator.decorateNodeChecker( dummyNodeCheck() );
RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> relationshipChecker =
decorator.decorateRelationshipChecker( dummyRelationshipChecker() );
RecordAccessStub records = new RecordAccessStub();
NodeRecord node = records.add( inUse( new NodeRecord( 1, NONE, 7 ) ) );
RelationshipRecord relationship = records.add( inUse( new RelationshipRecord( 1, 0, 1, 0 ) ) );
relationship.setNextProp( node.getNextProp() );
// when
ConsistencyReport.NodeConsistencyReport nodeReport =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node, records );
ConsistencyReport.RelationshipConsistencyReport relationshipReport =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship, records );
// then
verifyZeroInteractions( nodeReport );
verify( relationshipReport ).multipleOwners( node );
}
@Test
public void shouldReportRelationshipWithReferenceToTheGraphGlobalChain() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> relationshipChecker =
decorator.decorateRelationshipChecker( dummyRelationshipChecker() );
RecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> neoStoreCheck =
decorator.decorateNeoStoreChecker( dummyNeoStoreCheck() );
RecordAccessStub records = new RecordAccessStub();
NeoStoreRecord master = records.add( new NeoStoreRecord() );
master.setNextProp( 7 );
RelationshipRecord relationship = records.add( inUse( new RelationshipRecord( 1, 0, 1, 0 ) ) );
relationship.setNextProp( 7 );
// when
ConsistencyReport.NeoStoreConsistencyReport masterReport =
check( ConsistencyReport.NeoStoreConsistencyReport.class, neoStoreCheck, master, records );
ConsistencyReport.RelationshipConsistencyReport relationshipReport =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship, records );
// then
verifyZeroInteractions( masterReport );
verify( relationshipReport ).multipleOwners( master );
}
@Test
public void shouldReportNodeWithSamePropertyChainAsRelationship() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeChecker =
decorator.decorateNodeChecker( dummyNodeCheck() );
RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> relationshipChecker =
decorator.decorateRelationshipChecker( dummyRelationshipChecker() );
RecordAccessStub records = new RecordAccessStub();
NodeRecord node = records.add( inUse( new NodeRecord( 1, NONE, 7 ) ) );
RelationshipRecord relationship = records.add( inUse( new RelationshipRecord( 1, 0, 1, 0 ) ) );
relationship.setNextProp( node.getNextProp() );
// when
ConsistencyReport.RelationshipConsistencyReport relationshipReport =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship, records );
ConsistencyReport.NodeConsistencyReport nodeReport =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node, records );
// then
verifyZeroInteractions( relationshipReport );
verify( nodeReport ).multipleOwners( relationship );
}
@Test
public void shouldReportNodeWithReferenceToTheGraphGlobalChain() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeChecker =
decorator.decorateNodeChecker( dummyNodeCheck() );
RecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> neoStoreCheck =
decorator.decorateNeoStoreChecker( dummyNeoStoreCheck() );
RecordAccessStub records = new RecordAccessStub();
NodeRecord node = records.add( inUse( new NodeRecord( 1, NONE, 7 ) ) );
NeoStoreRecord master = records.add( new NeoStoreRecord() );
master.setNextProp( node.getNextProp() );
// when
ConsistencyReport.NeoStoreConsistencyReport masterReport =
check( ConsistencyReport.NeoStoreConsistencyReport.class, neoStoreCheck, master, records );
ConsistencyReport.NodeConsistencyReport nodeReport =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node, records );
// then
verifyZeroInteractions( masterReport );
verify( nodeReport ).multipleOwners( master );
}
@Test
public void shouldReportNodeStoreReferencingSameChainAsNode() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeChecker =
decorator.decorateNodeChecker( dummyNodeCheck() );
RecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> neoStoreCheck =
decorator.decorateNeoStoreChecker( dummyNeoStoreCheck() );
RecordAccessStub records = new RecordAccessStub();
NodeRecord node = records.add( inUse( new NodeRecord( 1, NONE, 7 ) ) );
NeoStoreRecord master = records.add( new NeoStoreRecord() );
master.setNextProp( node.getNextProp() );
// when
ConsistencyReport.NodeConsistencyReport nodeReport =
check( ConsistencyReport.NodeConsistencyReport.class, nodeChecker, node, records );
ConsistencyReport.NeoStoreConsistencyReport masterReport =
check( ConsistencyReport.NeoStoreConsistencyReport.class, neoStoreCheck, master, records );
// then
verifyZeroInteractions( nodeReport );
verify( masterReport ).multipleOwners( node );
}
@Test
public void shouldReportNodeStoreReferencingSameChainAsRelationship() throws Exception
{
// given
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> relationshipChecker =
decorator.decorateRelationshipChecker( dummyRelationshipChecker() );
RecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> neoStoreCheck =
decorator.decorateNeoStoreChecker( dummyNeoStoreCheck() );
RecordAccessStub records = new RecordAccessStub();
NeoStoreRecord master = records.add( new NeoStoreRecord() );
master.setNextProp( 7 );
RelationshipRecord relationship = records.add( inUse( new RelationshipRecord( 1, 0, 1, 0 ) ) );
relationship.setNextProp( 7 );
// when
ConsistencyReport.RelationshipConsistencyReport relationshipReport =
check( ConsistencyReport.RelationshipConsistencyReport.class,
relationshipChecker, relationship, records );
ConsistencyReport.NeoStoreConsistencyReport masterReport =
check( ConsistencyReport.NeoStoreConsistencyReport.class, neoStoreCheck, master, records );
// then
verifyZeroInteractions( relationshipReport );
verify( masterReport ).multipleOwners( relationship );
}
@Test
public void shouldReportOrphanPropertyChain() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true );
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> checker = decorator
.decoratePropertyChecker( dummyPropertyChecker() );
PropertyRecord record = inUse( new PropertyRecord( 42 ) );
ConsistencyReport.PropertyConsistencyReport report = check(
ConsistencyReport.PropertyConsistencyReport.class, checker, record, records );
// when
decorator.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verify( report ).orphanPropertyChain();
}
@Test
public void shouldNotReportOrphanIfOwnedByNode() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true );
PropertyRecord record = inUse( new PropertyRecord( 42 ) );
ConsistencyReport.PropertyConsistencyReport report =
check( ConsistencyReport.PropertyConsistencyReport.class,
decorator.decoratePropertyChecker( dummyPropertyChecker() ),
record, records );
ConsistencyReport.NodeConsistencyReport nodeReport =
check( ConsistencyReport.NodeConsistencyReport.class,
decorator.decorateNodeChecker( dummyNodeCheck() ),
inUse( new NodeRecord( 10, NONE, 42 ) ), records );
// when
decorator.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verifyNoMoreInteractions( report );
verifyNoMoreInteractions( nodeReport );
}
@Test
public void shouldNotReportOrphanIfOwnedByRelationship() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true );
PropertyRecord record = inUse( new PropertyRecord( 42 ) );
ConsistencyReport.PropertyConsistencyReport report =
check( ConsistencyReport.PropertyConsistencyReport.class,
decorator.decoratePropertyChecker( dummyPropertyChecker() ),
record, records );
RelationshipRecord relationship = inUse( new RelationshipRecord( 10, 1, 1, 0 ) );
relationship.setNextProp( 42 );
ConsistencyReport.RelationshipConsistencyReport relationshipReport =
check( ConsistencyReport.RelationshipConsistencyReport.class,
decorator.decorateRelationshipChecker( dummyRelationshipChecker() ),
relationship, records );
// when
decorator.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verifyNoMoreInteractions( report );
verifyNoMoreInteractions( relationshipReport );
}
@Test
public void shouldNotReportOrphanIfOwnedByNeoStore() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true );
PropertyRecord record = inUse( new PropertyRecord( 42 ) );
ConsistencyReport.PropertyConsistencyReport report =
check( ConsistencyReport.PropertyConsistencyReport.class,
decorator.decoratePropertyChecker( dummyPropertyChecker() ),
record, records );
NeoStoreRecord master = inUse( new NeoStoreRecord() );
master.setNextProp( 42 );
ConsistencyReport.NeoStoreConsistencyReport masterReport =
check( ConsistencyReport.NeoStoreConsistencyReport.class,
decorator.decorateNeoStoreChecker( dummyNeoStoreCheck() ),
master, records );
// when
decorator.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verifyNoMoreInteractions( report );
verifyNoMoreInteractions( masterReport );
}
@Test
public void shouldReportDynamicRecordOwnedByTwoOtherDynamicRecords() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.STRING );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> checker = decorator
.decorateDynamicChecker( RecordType.STRING_PROPERTY,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.STRING ) );
DynamicRecord record1 = records.add( inUse( string( new DynamicRecord( 1 ) ) ) );
DynamicRecord record2 = records.add( inUse( string( new DynamicRecord( 2 ) ) ) );
DynamicRecord record3 = records.add( inUse( string( new DynamicRecord( 3 ) ) ) );
record1.setNextBlock( record3.getId() );
record2.setNextBlock( record3.getId() );
// when
ConsistencyReport.DynamicConsistencyReport report1 = check( ConsistencyReport.DynamicConsistencyReport.class,
checker, record1, records );
ConsistencyReport.DynamicConsistencyReport report2 = check( ConsistencyReport.DynamicConsistencyReport.class,
checker, record2, records );
// then
verifyNoMoreInteractions( report1 );
verify( report2 ).nextMultipleOwners( record1 );
verifyNoMoreInteractions( report2 );
}
@Test
public void shouldReportDynamicStringRecordOwnedByTwoPropertyRecords() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.STRING );
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> propChecker = decorator
.decoratePropertyChecker( dummyPropertyChecker() );
DynamicRecord dynamic = records.add( inUse( string( new DynamicRecord( 42 ) ) ) );
PropertyRecord property1 = records.add( inUse( new PropertyRecord( 1 ) ) );
PropertyRecord property2 = records.add( inUse( new PropertyRecord( 2 ) ) );
PropertyKeyTokenRecord key = records.add( inUse( new PropertyKeyTokenRecord( 10 ) ) );
property1.addPropertyBlock( propertyBlock( key, PropertyType.STRING, dynamic.getId() ) );
property2.addPropertyBlock( propertyBlock( key, PropertyType.STRING, dynamic.getId() ) );
// when
ConsistencyReport.PropertyConsistencyReport report1 = check( ConsistencyReport.PropertyConsistencyReport.class,
propChecker, property1, records );
ConsistencyReport.PropertyConsistencyReport report2 = check( ConsistencyReport.PropertyConsistencyReport.class,
propChecker, property2, records );
// then
verifyNoMoreInteractions( report1 );
verify( report2 ).stringMultipleOwners( property1 );
verifyNoMoreInteractions( report2 );
}
@Test
public void shouldReportDynamicArrayRecordOwnedByTwoPropertyRecords() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.ARRAY );
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> propChecker = decorator
.decoratePropertyChecker( dummyPropertyChecker() );
DynamicRecord dynamic = records.add( inUse( array( new DynamicRecord( 42 ) ) ) );
PropertyRecord property1 = records.add( inUse( new PropertyRecord( 1 ) ) );
PropertyRecord property2 = records.add( inUse( new PropertyRecord( 2 ) ) );
PropertyKeyTokenRecord key = records.add( inUse( new PropertyKeyTokenRecord( 10 ) ) );
property1.addPropertyBlock( propertyBlock( key, PropertyType.ARRAY, dynamic.getId() ) );
property2.addPropertyBlock( propertyBlock( key, PropertyType.ARRAY, dynamic.getId() ) );
// when
ConsistencyReport.PropertyConsistencyReport report1 = check( ConsistencyReport.PropertyConsistencyReport.class,
propChecker, property1, records );
ConsistencyReport.PropertyConsistencyReport report2 = check( ConsistencyReport.PropertyConsistencyReport.class,
propChecker, property2, records );
// then
verifyNoMoreInteractions( report1 );
verify( report2 ).arrayMultipleOwners( property1 );
verifyNoMoreInteractions( report2 );
}
@Test
public void shouldReportDynamicRecordOwnedByPropertyAndOtherDynamic() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.STRING );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> dynChecker = decorator
.decorateDynamicChecker( RecordType.STRING_PROPERTY,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.STRING ) );
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> propChecker = decorator
.decoratePropertyChecker( dummyPropertyChecker() );
DynamicRecord owned = records.add( inUse( string( new DynamicRecord( 42 ) ) ) );
DynamicRecord dynamic = records.add( inUse( string( new DynamicRecord( 100 ) ) ) );
dynamic.setNextBlock( owned.getId() );
PropertyRecord property = records.add( inUse( new PropertyRecord( 1 ) ) );
PropertyKeyTokenRecord key = records.add( inUse( new PropertyKeyTokenRecord( 10 ) ) );
property.addPropertyBlock( propertyBlock( key, PropertyType.STRING, owned.getId() ) );
// when
ConsistencyReport.PropertyConsistencyReport propReport = check(
ConsistencyReport.PropertyConsistencyReport.class, propChecker, property, records );
ConsistencyReport.DynamicConsistencyReport dynReport = check(
ConsistencyReport.DynamicConsistencyReport.class, dynChecker, dynamic, records );
// then
verifyNoMoreInteractions( propReport );
verify( dynReport ).nextMultipleOwners( property );
verifyNoMoreInteractions( dynReport );
}
@Test
public void shouldReportDynamicStringRecordOwnedByOtherDynamicAndProperty() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.STRING );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> dynChecker = decorator
.decorateDynamicChecker( RecordType.STRING_PROPERTY,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.STRING ) );
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> propChecker = decorator
.decoratePropertyChecker( dummyPropertyChecker() );
DynamicRecord owned = records.add( inUse( string( new DynamicRecord( 42 ) ) ) );
DynamicRecord dynamic = records.add( inUse( string( new DynamicRecord( 100 ) ) ) );
dynamic.setNextBlock( owned.getId() );
PropertyRecord property = records.add( inUse( new PropertyRecord( 1 ) ) );
PropertyKeyTokenRecord key = records.add( inUse( new PropertyKeyTokenRecord( 10 ) ) );
property.addPropertyBlock( propertyBlock( key, PropertyType.STRING, owned.getId() ) );
// when
ConsistencyReport.DynamicConsistencyReport dynReport = check(
ConsistencyReport.DynamicConsistencyReport.class, dynChecker, dynamic, records );
ConsistencyReport.PropertyConsistencyReport propReport = check(
ConsistencyReport.PropertyConsistencyReport.class, propChecker, property, records );
// then
verifyNoMoreInteractions( dynReport );
verify( propReport ).stringMultipleOwners( dynamic );
verifyNoMoreInteractions( dynReport );
}
@Test
public void shouldReportDynamicArrayRecordOwnedByOtherDynamicAndProperty() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.ARRAY );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> dynChecker = decorator
.decorateDynamicChecker( RecordType.ARRAY_PROPERTY,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.ARRAY ) );
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> propChecker = decorator
.decoratePropertyChecker( dummyPropertyChecker() );
DynamicRecord owned = records.add( inUse( array( new DynamicRecord( 42 ) ) ) );
DynamicRecord dynamic = records.add( inUse( array( new DynamicRecord( 100 ) ) ) );
dynamic.setNextBlock( owned.getId() );
PropertyRecord property = records.add( inUse( new PropertyRecord( 1 ) ) );
PropertyKeyTokenRecord key = records.add( inUse( new PropertyKeyTokenRecord( 10 ) ) );
property.addPropertyBlock( propertyBlock( key, PropertyType.ARRAY, owned.getId() ) );
// when
ConsistencyReport.DynamicConsistencyReport dynReport = check(
ConsistencyReport.DynamicConsistencyReport.class, dynChecker, dynamic, records );
ConsistencyReport.PropertyConsistencyReport propReport = check(
ConsistencyReport.PropertyConsistencyReport.class, propChecker, property, records );
// then
verifyNoMoreInteractions( dynReport );
verify( propReport ).arrayMultipleOwners( dynamic );
verifyNoMoreInteractions( dynReport );
}
@Test
public void shouldReportDynamicRecordOwnedByTwoRelationshipLabels() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.RELATIONSHIP_TYPE );
RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> checker =
decorator.decorateRelationshipTypeTokenChecker( dummyRelationshipLabelCheck() );
DynamicRecord dynamic = records.addRelationshipTypeName( inUse( string( new DynamicRecord( 42 ) ) ) );
RelationshipTypeTokenRecord record1 = records.add( inUse( new RelationshipTypeTokenRecord( 1 ) ) );
RelationshipTypeTokenRecord record2 = records.add( inUse( new RelationshipTypeTokenRecord( 2 ) ) );
record1.setNameId( (int) dynamic.getId() );
record2.setNameId( (int) dynamic.getId() );
// when
ConsistencyReport.RelationshipTypeConsistencyReport report1 = check( ConsistencyReport.RelationshipTypeConsistencyReport.class,
checker,record1, records );
ConsistencyReport.RelationshipTypeConsistencyReport report2 = check( ConsistencyReport.RelationshipTypeConsistencyReport.class,
checker,record2, records );
// then
verifyNoMoreInteractions( report1 );
verify( report2 ).nameMultipleOwners( record1 );
verifyNoMoreInteractions( report2 );
}
@Test
public void shouldReportDynamicRecordOwnedByRelationshipLabelAndOtherDynamicRecord() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.RELATIONSHIP_TYPE );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> dynChecker =
decorator.decorateDynamicChecker(
RecordType.RELATIONSHIP_TYPE_NAME,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.RELATIONSHIP_TYPE ) );
RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> labelCheck =
decorator.decorateRelationshipTypeTokenChecker( dummyRelationshipLabelCheck() );
DynamicRecord owned = records.addRelationshipTypeName( inUse( string( new DynamicRecord( 42 ) ) ) );
DynamicRecord dynamic = records.addRelationshipTypeName( inUse( string( new DynamicRecord( 1 ) ) ) );
RelationshipTypeTokenRecord label = records.add( inUse( new RelationshipTypeTokenRecord( 1 ) ) );
dynamic.setNextBlock( owned.getId() );
label.setNameId( (int) owned.getId() );
// when
ConsistencyReport.RelationshipTypeConsistencyReport labelReport = check( ConsistencyReport.RelationshipTypeConsistencyReport.class,
labelCheck, label, records );
ConsistencyReport.DynamicConsistencyReport dynReport = check( ConsistencyReport.DynamicConsistencyReport.class,
dynChecker, dynamic, records );
// then
verifyNoMoreInteractions( labelReport );
verify( dynReport ).nextMultipleOwners( label );
verifyNoMoreInteractions( dynReport );
}
@Test
public void shouldReportDynamicRecordOwnedByOtherDynamicRecordAndRelationshipLabel() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.RELATIONSHIP_TYPE );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> dynChecker =
decorator.decorateDynamicChecker(
RecordType.RELATIONSHIP_TYPE_NAME,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.RELATIONSHIP_TYPE ) );
RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> labelCheck =
decorator.decorateRelationshipTypeTokenChecker( dummyRelationshipLabelCheck() );
DynamicRecord owned = records.addRelationshipTypeName( inUse( string( new DynamicRecord( 42 ) ) ) );
DynamicRecord dynamic = records.addRelationshipTypeName( inUse( string( new DynamicRecord( 1 ) ) ) );
RelationshipTypeTokenRecord label = records.add( inUse( new RelationshipTypeTokenRecord( 1 ) ) );
dynamic.setNextBlock( owned.getId() );
label.setNameId( (int) owned.getId() );
// when
ConsistencyReport.DynamicConsistencyReport dynReport = check( ConsistencyReport.DynamicConsistencyReport.class,
dynChecker, dynamic, records );
ConsistencyReport.RelationshipTypeConsistencyReport labelReport = check( ConsistencyReport.RelationshipTypeConsistencyReport.class,
labelCheck, label, records );
// then
verifyNoMoreInteractions( dynReport );
verify( labelReport ).nameMultipleOwners( dynamic );
verifyNoMoreInteractions( labelReport );
}
@Test
public void shouldReportDynamicRecordOwnedByTwoPropertyKeys() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.PROPERTY_KEY );
RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> checker =
decorator.decoratePropertyKeyTokenChecker( dummyPropertyKeyCheck() );
DynamicRecord dynamic = records.addPropertyKeyName( inUse( string( new DynamicRecord( 42 ) ) ) );
PropertyKeyTokenRecord record1 = records.add( inUse( new PropertyKeyTokenRecord( 1 ) ) );
PropertyKeyTokenRecord record2 = records.add( inUse( new PropertyKeyTokenRecord( 2 ) ) );
record1.setNameId( (int) dynamic.getId() );
record2.setNameId( (int) dynamic.getId() );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport report1 = check(
ConsistencyReport.PropertyKeyTokenConsistencyReport.class, checker,record1, records );
ConsistencyReport.PropertyKeyTokenConsistencyReport report2 = check(
ConsistencyReport.PropertyKeyTokenConsistencyReport.class, checker,record2, records );
// then
verifyNoMoreInteractions( report1 );
verify( report2 ).nameMultipleOwners( record1 );
verifyNoMoreInteractions( report2 );
}
@Test
public void shouldReportDynamicRecordOwnedByPropertyKeyAndOtherDynamicRecord() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.PROPERTY_KEY );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> dynChecker =
decorator.decorateDynamicChecker(
RecordType.PROPERTY_KEY_NAME,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.PROPERTY_KEY ) );
RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> keyCheck =
decorator.decoratePropertyKeyTokenChecker( dummyPropertyKeyCheck() );
DynamicRecord owned = records.addPropertyKeyName( inUse( string( new DynamicRecord( 42 ) ) ) );
DynamicRecord dynamic = records.addPropertyKeyName( inUse( string( new DynamicRecord( 1 ) ) ) );
PropertyKeyTokenRecord key = records.add( inUse( new PropertyKeyTokenRecord( 1 ) ) );
dynamic.setNextBlock( owned.getId() );
key.setNameId( (int) owned.getId() );
// when
ConsistencyReport.PropertyKeyTokenConsistencyReport keyReport = check(
ConsistencyReport.PropertyKeyTokenConsistencyReport.class, keyCheck, key, records );
ConsistencyReport.DynamicConsistencyReport dynReport = check(
ConsistencyReport.DynamicConsistencyReport.class, dynChecker, dynamic, records );
// then
verifyNoMoreInteractions( keyReport );
verify( dynReport ).nextMultipleOwners( key );
verifyNoMoreInteractions( dynReport );
}
@Test
public void shouldReportDynamicRecordOwnedByOtherDynamicRecordAndPropertyKey() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck decorator = new OwnerCheck( true, DynamicStore.PROPERTY_KEY );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> dynChecker =
decorator.decorateDynamicChecker(
RecordType.PROPERTY_KEY_NAME,
dummyDynamicCheck( configureDynamicStore( 50 ), DynamicStore.PROPERTY_KEY ) );
RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> keyCheck =
decorator.decoratePropertyKeyTokenChecker( dummyPropertyKeyCheck() );
DynamicRecord owned = records.addPropertyKeyName( inUse( string( new DynamicRecord( 42 ) ) ) );
DynamicRecord dynamic = records.addPropertyKeyName( inUse( string( new DynamicRecord( 1 ) ) ) );
PropertyKeyTokenRecord key = records.add( inUse( new PropertyKeyTokenRecord( 1 ) ) );
dynamic.setNextBlock( owned.getId() );
key.setNameId( (int) owned.getId() );
// when
ConsistencyReport.DynamicConsistencyReport dynReport = check(
ConsistencyReport.DynamicConsistencyReport.class,dynChecker, dynamic, records );
ConsistencyReport.PropertyKeyTokenConsistencyReport keyReport = check(
ConsistencyReport.PropertyKeyTokenConsistencyReport.class, keyCheck, key, records );
// then
verifyNoMoreInteractions( dynReport );
verify( keyReport ).nameMultipleOwners( dynamic );
verifyNoMoreInteractions( keyReport );
}
@Test
public void shouldReportOrphanedDynamicStringRecord() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck owners = new OwnerCheck( true, DynamicStore.STRING );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> stringCheck =
owners.decorateDynamicChecker( RecordType.STRING_PROPERTY,
dummyDynamicCheck( configureDynamicStore( 60 ),
DynamicStore.STRING ) );
DynamicRecord record = string( inUse( new DynamicRecord( 42 ) ) );
// when
ConsistencyReport.DynamicConsistencyReport report = check( ConsistencyReport.DynamicConsistencyReport.class,
stringCheck, record, records );
owners.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verify( report ).orphanDynamicRecord();
}
@Test
public void shouldReportOrphanedDynamicArrayRecord() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck owners = new OwnerCheck( true, DynamicStore.ARRAY );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> stringCheck =
owners.decorateDynamicChecker( RecordType.ARRAY_PROPERTY,
dummyDynamicCheck( configureDynamicStore( 60 ),
DynamicStore.ARRAY ) );
DynamicRecord record = string( inUse( new DynamicRecord( 42 ) ) );
// when
ConsistencyReport.DynamicConsistencyReport report = check( ConsistencyReport.DynamicConsistencyReport.class,
stringCheck, record, records );
owners.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verify( report ).orphanDynamicRecord();
}
@Test
public void shouldReportOrphanedDynamicRelationshipLabelRecord() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck owners = new OwnerCheck( true, DynamicStore.RELATIONSHIP_TYPE );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> stringCheck =
owners.decorateDynamicChecker( RecordType.RELATIONSHIP_TYPE_NAME,
dummyDynamicCheck( configureDynamicStore( 60 ),
DynamicStore.RELATIONSHIP_TYPE ) );
DynamicRecord record = string( inUse( new DynamicRecord( 42 ) ) );
// when
ConsistencyReport.DynamicConsistencyReport report = check( ConsistencyReport.DynamicConsistencyReport.class,
stringCheck, record, records );
owners.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verify( report ).orphanDynamicRecord();
}
@Test
public void shouldReportOrphanedDynamicPropertyKeyRecord() throws Exception
{
// given
RecordAccessStub records = new RecordAccessStub();
OwnerCheck owners = new OwnerCheck( true, DynamicStore.PROPERTY_KEY );
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> stringCheck =
owners.decorateDynamicChecker( RecordType.PROPERTY_KEY_NAME,
dummyDynamicCheck( configureDynamicStore( 60 ),
DynamicStore.PROPERTY_KEY ) );
DynamicRecord record = string( inUse( new DynamicRecord( 42 ) ) );
// when
ConsistencyReport.DynamicConsistencyReport report = check( ConsistencyReport.DynamicConsistencyReport.class,
stringCheck, record, records );
owners.scanForOrphanChains( ProgressMonitorFactory.NONE );
records.checkDeferred();
// then
verify( report ).orphanDynamicRecord();
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_OwnerCheckTest.java
|
4,164
|
private static class OrphanCheck implements Runnable
{
private final ConcurrentMap<Long, ? extends Owner> owners;
private final ProgressListener progress;
OrphanCheck( RecordType property, ConcurrentMap<Long, ? extends Owner> owners,
ProgressMonitorFactory.MultiPartBuilder progress )
{
this.owners = owners;
this.progress = progress.progressForPart( "Checking for orphan " + property.name() + " chains",
owners.size() );
}
@Override
public void run()
{
for ( Owner owner : owners.values() )
{
owner.checkOrphanage();
progress.add( 1 );
}
progress.done();
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,165
|
private static abstract class NameCheckerDecorator
<RECORD extends TokenRecord, REPORT extends ConsistencyReport.NameConsistencyReport>
implements RecordCheck<RECORD, REPORT>
{
private final RecordCheck<RECORD, REPORT> checker;
private final ConcurrentMap<Long, DynamicOwner> owners;
public NameCheckerDecorator( RecordCheck<RECORD, REPORT> checker, ConcurrentMap<Long, DynamicOwner> owners )
{
this.checker = checker;
this.owners = owners;
}
@SuppressWarnings("unchecked")
@Override
public void check( RECORD record, CheckerEngine<RECORD, REPORT> engine, RecordAccess records )
{
if ( record.inUse() )
{
DynamicOwner.NameOwner owner = owner( record );
DynamicOwner prev = owners.put( (long)record.getNameId(), owner );
if ( prev != null )
{
engine.comparativeCheck( prev.record( records ), owner );
}
}
checker.check( record, engine, records );
}
abstract DynamicOwner.NameOwner owner( RECORD record );
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,166
|
{
@Override
public void checkReference( PropertyRecord record, PrimitiveRecord primitiveRecord,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
engine.report().orphanPropertyChain();
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,167
|
{
@Override
public void check( DynamicRecord record,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
RecordAccess records )
{
if ( record.inUse() )
{
DynamicOwner.Unknown owner = new DynamicOwner.Unknown();
engine.comparativeCheck( owner, DynamicOwner.ORPHAN_CHECK );
if ( null == dynamicOwners.putIfAbsent( record.getId(), owner ) )
{
owner.markInCustody();
}
if ( !Record.NO_NEXT_BLOCK.is( record.getNextBlock() ) )
{
DynamicOwner.Dynamic nextOwner = new DynamicOwner.Dynamic( type, record );
DynamicOwner prevOwner = dynamicOwners.put( record.getNextBlock(), nextOwner );
if ( prevOwner != null )
{
engine.comparativeCheck( prevOwner.record( records ), nextOwner );
}
}
}
checker.check( record, engine, records );
}
@Override
public void checkChange( DynamicRecord oldRecord, DynamicRecord newRecord,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,168
|
{
@Override
DynamicOwner.NameOwner owner( LabelTokenRecord record )
{
return new DynamicOwner.LabelToken( record );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,169
|
{
@Override
DynamicOwner.NameOwner owner( RelationshipTypeTokenRecord record )
{
return new DynamicOwner.RelationshipTypeToken( record );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,170
|
{
@Override
DynamicOwner.NameOwner owner( PropertyKeyTokenRecord record )
{
return new DynamicOwner.PropertyKey( record );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,171
|
{
@Override
public void check( PropertyRecord record,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( record.inUse() )
{
if ( owners != null && Record.NO_PREVIOUS_PROPERTY.is( record.getPrevProp() ) )
{ // this record is first in a chain
PropertyOwner.UnknownOwner owner = new PropertyOwner.UnknownOwner();
engine.comparativeCheck( owner, ORPHAN_CHECKER );
if ( null == owners.putIfAbsent( record.getId(), owner ) )
{
owner.markInCustody();
}
}
if ( dynamics != null )
{
List<PropertyBlock> blocks = record.getPropertyBlocks();
for ( PropertyBlock block : blocks )
{
RecordType type = recordType( block.forceGetType() );
if ( type != null )
{
ConcurrentMap<Long, DynamicOwner> dynamicOwners = dynamics.get( type );
if ( dynamicOwners != null )
{
long id = block.getSingleValueLong();
DynamicOwner.Property owner = new DynamicOwner.Property( type, record );
DynamicOwner prev = dynamicOwners.put( id, owner );
if ( prev != null )
{
engine.comparativeCheck( prev.record( records ), owner );
}
}
}
}
}
}
checker.check( record, engine, records );
}
@Override
public void checkChange( PropertyRecord oldRecord, PropertyRecord newRecord,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,172
|
{
PropertyOwner owner( RelationshipRecord record )
{
return new PropertyOwner.OwningRelationship( record );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,173
|
{
PropertyOwner owner( NodeRecord record )
{
return new PropertyOwner.OwningNode( record );
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,174
|
{
PropertyOwner owner( NeoStoreRecord record )
{
return PropertyOwner.OWNING_GRAPH;
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,175
|
class OwnerCheck implements CheckDecorator
{
private final ConcurrentMap<Long, PropertyOwner> owners;
private final Map<RecordType, ConcurrentMap<Long, DynamicOwner>> dynamics;
OwnerCheck( boolean active, DynamicStore... stores )
{
this.owners = active ? new ConcurrentHashMap<Long, PropertyOwner>( 16, 0.75f, 4 ) : null;
this.dynamics = active ? initialize( stores ) : null;
}
private static Map<RecordType, ConcurrentMap<Long, DynamicOwner>> initialize( DynamicStore[] stores )
{
EnumMap<RecordType, ConcurrentMap<Long, DynamicOwner>> map =
new EnumMap<>( RecordType.class );
for ( DynamicStore store : stores )
{
map.put( store.type, new ConcurrentHashMap<Long, DynamicOwner>( 16, 0.75f, 4 ) );
}
return unmodifiableMap( map );
}
void scanForOrphanChains( ProgressMonitorFactory progressFactory )
{
List<Runnable> tasks = new ArrayList<>();
ProgressMonitorFactory.MultiPartBuilder progress = progressFactory
.multipleParts( "Checking for orphan chains" );
if ( owners != null )
{
tasks.add( new OrphanCheck( RecordType.PROPERTY, owners, progress ) );
}
if ( dynamics != null )
{
for ( Map.Entry<RecordType, ConcurrentMap<Long, DynamicOwner>> entry : dynamics.entrySet() )
{
tasks.add( new OrphanCheck( entry.getKey(), entry.getValue(), progress ) );
}
}
for ( Runnable task : tasks )
{
task.run();
}
}
private static class OrphanCheck implements Runnable
{
private final ConcurrentMap<Long, ? extends Owner> owners;
private final ProgressListener progress;
OrphanCheck( RecordType property, ConcurrentMap<Long, ? extends Owner> owners,
ProgressMonitorFactory.MultiPartBuilder progress )
{
this.owners = owners;
this.progress = progress.progressForPart( "Checking for orphan " + property.name() + " chains",
owners.size() );
}
@Override
public void run()
{
for ( Owner owner : owners.values() )
{
owner.checkOrphanage();
progress.add( 1 );
}
progress.done();
}
}
@Override
public RecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> decorateNeoStoreChecker(
PrimitiveRecordCheck<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport> checker )
{
if ( owners == null )
{
return checker;
}
return new PrimitiveCheckerDecorator<NeoStoreRecord, ConsistencyReport.NeoStoreConsistencyReport>( checker )
{
PropertyOwner owner( NeoStoreRecord record )
{
return PropertyOwner.OWNING_GRAPH;
}
};
}
@Override
public RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> decorateNodeChecker(
PrimitiveRecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> checker )
{
if ( owners == null )
{
return checker;
}
return new PrimitiveCheckerDecorator<NodeRecord, ConsistencyReport.NodeConsistencyReport>( checker )
{
PropertyOwner owner( NodeRecord record )
{
return new PropertyOwner.OwningNode( record );
}
};
}
@Override
public RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> decorateRelationshipChecker(
PrimitiveRecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> checker )
{
if ( owners == null )
{
return checker;
}
return new PrimitiveCheckerDecorator<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport>(
checker )
{
PropertyOwner owner( RelationshipRecord record )
{
return new PropertyOwner.OwningRelationship( record );
}
};
}
@Override
public RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> decoratePropertyChecker(
final RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> checker )
{
if ( owners == null && dynamics == null )
{
return checker;
}
return new RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport>()
{
@Override
public void check( PropertyRecord record,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
if ( record.inUse() )
{
if ( owners != null && Record.NO_PREVIOUS_PROPERTY.is( record.getPrevProp() ) )
{ // this record is first in a chain
PropertyOwner.UnknownOwner owner = new PropertyOwner.UnknownOwner();
engine.comparativeCheck( owner, ORPHAN_CHECKER );
if ( null == owners.putIfAbsent( record.getId(), owner ) )
{
owner.markInCustody();
}
}
if ( dynamics != null )
{
List<PropertyBlock> blocks = record.getPropertyBlocks();
for ( PropertyBlock block : blocks )
{
RecordType type = recordType( block.forceGetType() );
if ( type != null )
{
ConcurrentMap<Long, DynamicOwner> dynamicOwners = dynamics.get( type );
if ( dynamicOwners != null )
{
long id = block.getSingleValueLong();
DynamicOwner.Property owner = new DynamicOwner.Property( type, record );
DynamicOwner prev = dynamicOwners.put( id, owner );
if ( prev != null )
{
engine.comparativeCheck( prev.record( records ), owner );
}
}
}
}
}
}
checker.check( record, engine, records );
}
@Override
public void checkChange( PropertyRecord oldRecord, PropertyRecord newRecord,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
};
}
private RecordType recordType( PropertyType type )
{
if ( type != null )
{
switch ( type )
{
case STRING:
return STRING_PROPERTY;
case ARRAY:
return ARRAY_PROPERTY;
}
}
return null;
}
@Override
public RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> decoratePropertyKeyTokenChecker(
RecordCheck<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> checker )
{
ConcurrentMap<Long, DynamicOwner> dynamicOwners = dynamicOwners( PROPERTY_KEY_NAME );
if ( dynamicOwners == null )
{
return checker;
}
return new NameCheckerDecorator
<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport>( checker, dynamicOwners )
{
@Override
DynamicOwner.NameOwner owner( PropertyKeyTokenRecord record )
{
return new DynamicOwner.PropertyKey( record );
}
};
}
@Override
public RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> decorateRelationshipTypeTokenChecker(
RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> checker )
{
ConcurrentMap<Long, DynamicOwner> dynamicOwners = dynamicOwners( RELATIONSHIP_TYPE_NAME );
if ( dynamicOwners == null )
{
return checker;
}
return new NameCheckerDecorator
<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport>( checker, dynamicOwners )
{
@Override
DynamicOwner.NameOwner owner( RelationshipTypeTokenRecord record )
{
return new DynamicOwner.RelationshipTypeToken( record );
}
};
}
@Override
public RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport> decorateLabelTokenChecker(
RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport> checker )
{
ConcurrentMap<Long, DynamicOwner> dynamicOwners = dynamicOwners( RELATIONSHIP_TYPE_NAME );
if ( dynamicOwners == null )
{
return checker;
}
return new NameCheckerDecorator<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport>( checker, dynamicOwners )
{
@Override
DynamicOwner.NameOwner owner( LabelTokenRecord record )
{
return new DynamicOwner.LabelToken( record );
}
};
}
@Override
public RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> decorateLabelMatchChecker(
RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> checker )
{
// TODO: Understand what this does.
return checker;
}
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> decorateDynamicChecker(
final RecordType type, final RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> checker )
{
final ConcurrentMap<Long, DynamicOwner> dynamicOwners = dynamicOwners( type );
if ( dynamicOwners == null )
{
return checker;
}
return new RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport>()
{
@Override
public void check( DynamicRecord record,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
RecordAccess records )
{
if ( record.inUse() )
{
DynamicOwner.Unknown owner = new DynamicOwner.Unknown();
engine.comparativeCheck( owner, DynamicOwner.ORPHAN_CHECK );
if ( null == dynamicOwners.putIfAbsent( record.getId(), owner ) )
{
owner.markInCustody();
}
if ( !Record.NO_NEXT_BLOCK.is( record.getNextBlock() ) )
{
DynamicOwner.Dynamic nextOwner = new DynamicOwner.Dynamic( type, record );
DynamicOwner prevOwner = dynamicOwners.put( record.getNextBlock(), nextOwner );
if ( prevOwner != null )
{
engine.comparativeCheck( prevOwner.record( records ), nextOwner );
}
}
}
checker.check( record, engine, records );
}
@Override
public void checkChange( DynamicRecord oldRecord, DynamicRecord newRecord,
CheckerEngine<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
};
}
private ConcurrentMap<Long, DynamicOwner> dynamicOwners( RecordType type )
{
return dynamics == null ? null : dynamics.get( type );
}
private abstract class PrimitiveCheckerDecorator<RECORD extends PrimitiveRecord,
REPORT extends ConsistencyReport.PrimitiveConsistencyReport>
implements RecordCheck<RECORD, REPORT>
{
private final PrimitiveRecordCheck<RECORD, REPORT> checker;
PrimitiveCheckerDecorator( PrimitiveRecordCheck<RECORD, REPORT> checker )
{
this.checker = checker;
}
@Override
@SuppressWarnings("unchecked")
public void check( RECORD record, CheckerEngine<RECORD, REPORT> engine, RecordAccess records )
{
if ( record.inUse() )
{
long prop = record.getNextProp();
if ( !Record.NO_NEXT_PROPERTY.is( prop ) )
{
PropertyOwner previous = owners.put( prop, owner( record ) );
if ( previous != null )
{
engine.comparativeCheck( previous.record( records ), checker.ownerCheck );
}
}
}
checker.check( record, engine, records );
}
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
abstract PropertyOwner owner( RECORD record );
}
private static abstract class NameCheckerDecorator
<RECORD extends TokenRecord, REPORT extends ConsistencyReport.NameConsistencyReport>
implements RecordCheck<RECORD, REPORT>
{
private final RecordCheck<RECORD, REPORT> checker;
private final ConcurrentMap<Long, DynamicOwner> owners;
public NameCheckerDecorator( RecordCheck<RECORD, REPORT> checker, ConcurrentMap<Long, DynamicOwner> owners )
{
this.checker = checker;
this.owners = owners;
}
@SuppressWarnings("unchecked")
@Override
public void check( RECORD record, CheckerEngine<RECORD, REPORT> engine, RecordAccess records )
{
if ( record.inUse() )
{
DynamicOwner.NameOwner owner = owner( record );
DynamicOwner prev = owners.put( (long)record.getNameId(), owner );
if ( prev != null )
{
engine.comparativeCheck( prev.record( records ), owner );
}
}
checker.check( record, engine, records );
}
abstract DynamicOwner.NameOwner owner( RECORD record );
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
}
private static final ComparativeRecordChecker<PropertyRecord, PrimitiveRecord, ConsistencyReport.PropertyConsistencyReport> ORPHAN_CHECKER =
new ComparativeRecordChecker<PropertyRecord, PrimitiveRecord, ConsistencyReport.PropertyConsistencyReport>()
{
@Override
public void checkReference( PropertyRecord record, PrimitiveRecord primitiveRecord,
CheckerEngine<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> engine,
RecordAccess records )
{
engine.report().orphanPropertyChain();
}
};
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,176
|
public class NullReporter implements ConsistencyReport.Reporter
{
@Override
public void forSchema( DynamicRecord schema, RecordCheck<DynamicRecord, ConsistencyReport.SchemaConsistencyReport
> checker )
{
}
@Override
public void forSchemaChange( DynamicRecord oldSchema, DynamicRecord newSchema, RecordCheck<DynamicRecord,
ConsistencyReport.SchemaConsistencyReport> checker )
{
}
@Override
public void forNode( NodeRecord node, RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> checker )
{
}
@Override
public void forNodeChange( NodeRecord oldNode, NodeRecord newNode, RecordCheck<NodeRecord, ConsistencyReport
.NodeConsistencyReport> checker )
{
}
@Override
public void forRelationship( RelationshipRecord relationship, RecordCheck<RelationshipRecord, ConsistencyReport
.RelationshipConsistencyReport> checker )
{
}
@Override
public void forRelationshipChange( RelationshipRecord oldRelationship, RelationshipRecord newRelationship, RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> checker )
{
}
@Override
public void forProperty( PropertyRecord property, RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> checker )
{
}
@Override
public void forPropertyChange( PropertyRecord oldProperty, PropertyRecord newProperty,
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> checker )
{
}
@Override
public void forRelationshipTypeName( RelationshipTypeTokenRecord relationshipType, RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> checker )
{
}
@Override
public void forRelationshipTypeNameChange( RelationshipTypeTokenRecord oldType, RelationshipTypeTokenRecord newType, RecordCheck<RelationshipTypeTokenRecord, ConsistencyReport.RelationshipTypeConsistencyReport> checker )
{
}
@Override
public void forLabelName( LabelTokenRecord label, RecordCheck<LabelTokenRecord, ConsistencyReport
.LabelTokenConsistencyReport> checker )
{
}
@Override
public void forLabelNameChange( LabelTokenRecord oldLabel, LabelTokenRecord newLabel,
RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport>
checker )
{
}
@Override
public void forPropertyKey( PropertyKeyTokenRecord key, RecordCheck<PropertyKeyTokenRecord,
ConsistencyReport.PropertyKeyTokenConsistencyReport> checker )
{
}
@Override
public void forPropertyKeyChange( PropertyKeyTokenRecord oldKey, PropertyKeyTokenRecord newKey, RecordCheck
<PropertyKeyTokenRecord, ConsistencyReport.PropertyKeyTokenConsistencyReport> checker )
{
}
@Override
public void forDynamicBlock( RecordType type, DynamicRecord record, RecordCheck<DynamicRecord, ConsistencyReport
.DynamicConsistencyReport> checker )
{
}
@Override
public void forDynamicBlockChange( RecordType type, DynamicRecord oldRecord, DynamicRecord newRecord, RecordCheck
<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> checker )
{
}
@Override
public void forDynamicLabelBlock( RecordType type, DynamicRecord record, RecordCheck<DynamicRecord, ConsistencyReport.DynamicLabelConsistencyReport> checker )
{
}
@Override
public void forDynamicLabelBlockChange( RecordType type, DynamicRecord oldRecord, DynamicRecord newRecord, RecordCheck<DynamicRecord, ConsistencyReport.DynamicLabelConsistencyReport> checker )
{
}
@Override
public void forNodeLabelScan( LabelScanDocument document, RecordCheck<LabelScanDocument, ConsistencyReport.LabelScanConsistencyReport> checker )
{
}
@Override
public void forIndexEntry( IndexEntry entry, RecordCheck<IndexEntry, ConsistencyReport.IndexConsistencyReport>
checker )
{
}
@Override
public void forNodeLabelMatch( NodeRecord nodeRecord, RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> nodeLabelCheck )
{
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_NullReporter.java
|
4,177
|
public class NodeToLabelScanRecordProcessor implements RecordProcessor<NodeRecord>
{
private final ConsistencyReporter reporter;
private final RecordCheck<NodeRecord, ConsistencyReport.LabelsMatchReport> nodeLabelCheck;
private final LabelScanReader reader;
public NodeToLabelScanRecordProcessor(
ConsistencyReporter reporter, LabelScanStore labelScanStore )
{
this.reporter = reporter;
this.reader = labelScanStore.newReader();
this.nodeLabelCheck = new LabelsMatchCheck( reader );
}
@Override
public void process( NodeRecord nodeRecord )
{
reporter.forNodeLabelMatch( nodeRecord, nodeLabelCheck );
}
@Override
public void close()
{
reader.close();
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_NodeToLabelScanRecordProcessor.java
|
4,178
|
public class NodeToLabelIndexesProcessor implements RecordProcessor<NodeRecord>
{
private final ConsistencyReporter reporter;
private final RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> nodeIndexCheck;
public NodeToLabelIndexesProcessor( ConsistencyReporter reporter,
IndexAccessors indexes,
PropertyReader propertyReader )
{
this.reporter = reporter;
this.nodeIndexCheck = new NodeCorrectlyIndexedCheck( indexes, propertyReader );
}
@Override
public void process( NodeRecord nodeRecord )
{
reporter.forNode( nodeRecord, nodeIndexCheck );
}
@Override
public void close()
{
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_NodeToLabelIndexesProcessor.java
|
4,179
|
{
@Override
public void onRecordNotInUse( DynamicRecord dynamicRecord,
CheckerEngine<NodeRecord, REPORT> engine )
{
}
@Override
public void onRecordChainCycle( DynamicRecord record,
CheckerEngine<NodeRecord, REPORT> engine )
{
}
@Override
public void onWellFormedChain( long[] labelIds,
CheckerEngine<NodeRecord, REPORT> engine,
RecordAccess records )
{
copyToSet( labelIds, labels );
}
} ) );
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_NodeLabelReader.java
|
4,180
|
public class NodeLabelReader
{
public static <REPORT extends ConsistencyReport> Set<Long> getListOfLabels(
NodeRecord nodeRecord, RecordAccess records, CheckerEngine<NodeRecord, REPORT> engine )
{
final Set<Long> labels = new HashSet<>();
NodeLabels nodeLabels = NodeLabelsField.parseLabelsField( nodeRecord );
if ( nodeLabels instanceof DynamicNodeLabels )
{
DynamicNodeLabels dynamicNodeLabels = (DynamicNodeLabels) nodeLabels;
long firstRecordId = dynamicNodeLabels.getFirstDynamicRecordId();
RecordReference<DynamicRecord> firstRecordReference = records.nodeLabels( firstRecordId );
engine.comparativeCheck( firstRecordReference,
new LabelChainWalker<>(
new LabelChainWalker.Validator<NodeRecord, REPORT>()
{
@Override
public void onRecordNotInUse( DynamicRecord dynamicRecord,
CheckerEngine<NodeRecord, REPORT> engine )
{
}
@Override
public void onRecordChainCycle( DynamicRecord record,
CheckerEngine<NodeRecord, REPORT> engine )
{
}
@Override
public void onWellFormedChain( long[] labelIds,
CheckerEngine<NodeRecord, REPORT> engine,
RecordAccess records )
{
copyToSet( labelIds, labels );
}
} ) );
}
else
{
copyToSet( nodeLabels.get( null ), labels );
}
return labels;
}
private static void copyToSet( long[] array, Set<Long> set )
{
for ( long labelId : array )
{
set.add( labelId );
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_NodeLabelReader.java
|
4,181
|
public class NodeInUseWithCorrectLabelsCheckTest
{
@Test
public void shouldReportNodeNotInUse() throws Exception
{
// given
int nodeId = 42;
ConsistencyReport.LabelScanConsistencyReport report =
mock( ConsistencyReport.LabelScanConsistencyReport.class );
NodeRecord node = notInUse( new NodeRecord( nodeId, 0, 0 ) );
// when
checker( new long[]{} ).checkReference( null, node, engineFor( report ), null );
// then
verify( report ).nodeNotInUse( node );
}
@Test
public void shouldReportNodeWithoutExpectedLabelWhenLabelsAreInline() throws Exception
{
// given
int nodeId = 42;
int labelId1 = 7;
int labelId2 = 9;
NodeRecord node = inUse( withInlineLabels( new NodeRecord( nodeId, 0, 0 ), labelId1 ) );
ConsistencyReport.LabelScanConsistencyReport report =
mock( ConsistencyReport.LabelScanConsistencyReport.class );
// when
checker(new long[] {labelId1, labelId2}).checkReference( null, node, engineFor( report ), null );
// then
verify( report ).nodeDoesNotHaveExpectedLabel( node, labelId2 );
}
@Test
public void shouldReportNodeWithoutExpectedLabelWhenLabelsAreDynamic() throws Exception
{
// given
int nodeId = 42;
long[] expectedLabelIds = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
long[] presentLabelIds = {1, 2, 3, 4, 5, 6, 8, 9, 10};
long missingLabelId = 7;
RecordAccessStub recordAccess = new RecordAccessStub();
NodeRecord node = inUse( withDynamicLabels( recordAccess, new NodeRecord( nodeId, 0, 0 ), presentLabelIds ) );
ConsistencyReport.LabelScanConsistencyReport report =
mock( ConsistencyReport.LabelScanConsistencyReport.class );
// when
CheckerEngine<LabelScanDocument, ConsistencyReport.LabelScanConsistencyReport> engine = recordAccess.engine( null, report );
checker( expectedLabelIds ).checkReference( null, node, engine, recordAccess );
recordAccess.checkDeferred();
// then
verify( report ).nodeDoesNotHaveExpectedLabel( node, missingLabelId );
}
@Test
public void shouldRemainSilentWhenEverythingIsInOrder() throws Exception
{
// given
int nodeId = 42;
int labelId = 7;
NodeRecord node = withInlineLabels( inUse( new NodeRecord( nodeId, 0, 0 ) ), labelId );
ConsistencyReport.LabelScanConsistencyReport report =
mock( ConsistencyReport.LabelScanConsistencyReport.class );
// when
checker( new long[]{labelId} ).checkReference( null, node, engineFor( report ), null );
// then
verifyNoMoreInteractions( report );
}
private NodeRecord withInlineLabels( NodeRecord nodeRecord, long... labelIds )
{
new InlineNodeLabels( nodeRecord.getLabelField(), nodeRecord ).put( labelIds, null );
return nodeRecord;
}
private NodeRecord withDynamicLabels( RecordAccessStub recordAccess, NodeRecord nodeRecord, long... labelIds )
{
List<DynamicRecord> preAllocatedRecords = new ArrayList<>();
for ( int i = 0; i < 10; i++ )
{
preAllocatedRecords.add( inUse( new DynamicRecord( i ) ) );
}
Collection<DynamicRecord> dynamicRecords =
DynamicArrayStore.allocateFromNumbers( prependNodeId( nodeRecord.getId(), labelIds ),
preAllocatedRecords.iterator(), new PreAllocatedRecords( 4 ) );
for ( DynamicRecord dynamicRecord : dynamicRecords )
{
recordAccess.addNodeDynamicLabels( dynamicRecord );
}
nodeRecord.setLabelField( dynamicPointer( dynamicRecords ), dynamicRecords );
return nodeRecord;
}
@SuppressWarnings("unchecked")
private Engine engineFor( ConsistencyReport.LabelScanConsistencyReport report )
{
Engine engine = mock( Engine.class );
when( engine.report() ).thenReturn( report );
return engine;
}
private NodeInUseWithCorrectLabelsCheck<LabelScanDocument, ConsistencyReport.LabelScanConsistencyReport> checker( long[] expectedLabels )
{
return new NodeInUseWithCorrectLabelsCheck<LabelScanDocument, ConsistencyReport.LabelScanConsistencyReport>( expectedLabels );
}
interface Engine extends CheckerEngine<LabelScanDocument, ConsistencyReport.LabelScanConsistencyReport>
{
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_NodeInUseWithCorrectLabelsCheckTest.java
|
4,182
|
private class ExpectedNodeLabelsChecker implements
LabelChainWalker.Validator<RECORD, REPORT>
{
private final NodeRecord nodeRecord;
public ExpectedNodeLabelsChecker( NodeRecord nodeRecord )
{
this.nodeRecord = nodeRecord;
}
@Override
public void onRecordNotInUse( DynamicRecord dynamicRecord, CheckerEngine<RECORD, REPORT> engine )
{
// checked elsewhere
}
@Override
public void onRecordChainCycle( DynamicRecord record, CheckerEngine<RECORD, REPORT> engine )
{
// checked elsewhere
}
@Override
public void onWellFormedChain( long[] labelIds, CheckerEngine<RECORD, REPORT> engine, RecordAccess records )
{
validateLabelIds( nodeRecord, labelIds, engine.report() );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_NodeInUseWithCorrectLabelsCheck.java
|
4,183
|
private abstract class PrimitiveCheckerDecorator<RECORD extends PrimitiveRecord,
REPORT extends ConsistencyReport.PrimitiveConsistencyReport>
implements RecordCheck<RECORD, REPORT>
{
private final PrimitiveRecordCheck<RECORD, REPORT> checker;
PrimitiveCheckerDecorator( PrimitiveRecordCheck<RECORD, REPORT> checker )
{
this.checker = checker;
}
@Override
@SuppressWarnings("unchecked")
public void check( RECORD record, CheckerEngine<RECORD, REPORT> engine, RecordAccess records )
{
if ( record.inUse() )
{
long prop = record.getNextProp();
if ( !Record.NO_NEXT_PROPERTY.is( prop ) )
{
PropertyOwner previous = owners.put( prop, owner( record ) );
if ( previous != null )
{
engine.comparativeCheck( previous.record( records ), checker.ownerCheck );
}
}
}
checker.check( record, engine, records );
}
@Override
public void checkChange( RECORD oldRecord, RECORD newRecord, CheckerEngine<RECORD, REPORT> engine,
DiffRecordAccess records )
{
checker.checkChange( oldRecord, newRecord, engine, records );
}
abstract PropertyOwner owner( RECORD record );
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_OwnerCheck.java
|
4,184
|
abstract class PropertyOwner<RECORD extends PrimitiveRecord> implements Owner
{
abstract RecordReference<RECORD> record( RecordAccess records );
public void checkOrphanage()
{
// default: do nothing
}
static class OwningNode extends PropertyOwner<NodeRecord>
{
private final long id;
OwningNode( NodeRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<NodeRecord> record( RecordAccess records )
{
return records.node( id );
}
}
static class OwningRelationship extends PropertyOwner<RelationshipRecord>
{
private final long id;
OwningRelationship( RelationshipRecord record )
{
this.id = record.getId();
}
@Override
RecordReference<RelationshipRecord> record( RecordAccess records )
{
return records.relationship( id );
}
}
static final PropertyOwner<NeoStoreRecord> OWNING_GRAPH = new PropertyOwner<NeoStoreRecord>()
{
@Override
RecordReference<NeoStoreRecord> record( RecordAccess records )
{
return records.graph();
}
};
static class UnknownOwner extends PropertyOwner<PrimitiveRecord> implements RecordReference<PrimitiveRecord>
{
private PendingReferenceCheck<PrimitiveRecord> reporter;
@Override
RecordReference<PrimitiveRecord> record( RecordAccess records )
{
// Getting the record for this owner means that some other owner replaced it
// that means that it isn't an orphan, so we skip this orphan check
// and return a record for conflict check that always is ok (by skipping the check)
this.markInCustody();
return skipReference();
}
@Override
public void checkOrphanage()
{
PendingReferenceCheck<PrimitiveRecord> reporter;
synchronized ( this )
{
reporter = this.reporter;
this.reporter = null;
}
if ( reporter != null )
{
reporter.checkReference( null, null );
}
}
synchronized void markInCustody()
{
if ( reporter != null )
{
reporter.skip();
reporter = null;
}
}
@Override
public synchronized void dispatch( PendingReferenceCheck<PrimitiveRecord> reporter )
{
this.reporter = reporter;
}
}
private PropertyOwner()
{
// only internal subclasses
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_PropertyOwner.java
|
4,185
|
public class FullCheckIntegrationTest
{
@Rule
public final GraphStoreFixture fixture = new GraphStoreFixture()
{
@Override
protected void generateInitialData( GraphDatabaseService graphDb )
{
try ( org.neo4j.graphdb.Transaction tx = graphDb.beginTx())
{
graphDb.schema().indexFor( label("label3") ).on( "key" ).create();
graphDb.schema().constraintFor( label( "label4" ) ).assertPropertyIsUnique( "key" ).create();
tx.success();
}
try ( org.neo4j.graphdb.Transaction tx = graphDb.beginTx())
{
Node node1 = set( graphDb.createNode( label( "label1" ) ) );
Node node2 = set( graphDb.createNode( label( "label2" ) ), property( "key", "value" ) );
node1.createRelationshipTo( node2, withName( "C" ) );
indexedNodes.add( set( graphDb.createNode( label( "label3" ) ), property( "key", "value" ) ).getId() );
set( graphDb.createNode( label( "label4" ) ), property( "key", "value" ) );
tx.success();
}
}
};
private final StringWriter log = new StringWriter();
private final List<Long> indexedNodes = new ArrayList<>();
private ConsistencySummaryStatistics check() throws ConsistencyCheckIncompleteException
{
return check( fixture.directStoreAccess() );
}
private ConsistencySummaryStatistics check( DirectStoreAccess stores ) throws ConsistencyCheckIncompleteException
{
FullCheck checker = new FullCheck( config( TaskExecutionOrder.MULTI_PASS ), ProgressMonitorFactory.NONE );
return checker.execute( stores, StringLogger.wrap( log ) );
}
private void verifyInconsistency( ConsistencySummaryStatistics stats, RecordType... recordTypes )
{
int totalInconsistencyCount = 0;
for ( RecordType recordType : recordTypes )
{
int count = stats.getInconsistencyCountForRecordType( recordType );
assertTrue( "Expected inconsistencies for records of type " + recordType, count > 0 );
totalInconsistencyCount += count;
}
assertEquals( "Expected only inconsistencies of type " + Arrays.toString( recordTypes ) + ", got:\n" + log,
totalInconsistencyCount, stats.getTotalInconsistencyCount() );
}
@Test
public void shouldCheckConsistencyOfAConsistentStore() throws Exception
{
// when
ConsistencySummaryStatistics result = check();
// then
assertEquals( 0, result.getTotalInconsistencyCount() );
}
@Test
@Ignore("Support for checking NeoStore needs to be added")
public void shouldReportNeoStoreInconsistencies() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NeoStoreRecord record = new NeoStoreRecord();
record.setNextProp( next.property() );
tx.update( record );
// We get exceptions when only the above happens in a transaction...
tx.create( new NodeRecord( next.node(), -1, -1 ) );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NEO_STORE );
}
@Test
public void shouldReportNodeInconsistencies() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
tx.create( new NodeRecord( next.node(), next.relationship(), -1 ) );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
@Test
public void shouldReportInlineNodeLabelInconsistencies() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NodeRecord nodeRecord = new NodeRecord( next.node(), -1, -1 );
NodeLabelsField.parseLabelsField( nodeRecord ).add( 10, null );
tx.create( nodeRecord );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
@Test
public void shouldReportNodeDynamicLabelContainingUnknownLabelAsNodeInconsistency() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NodeRecord nodeRecord = new NodeRecord( next.node(), -1, -1 );
DynamicRecord record = inUse( new DynamicRecord( next.nodeLabel() ) );
Collection<DynamicRecord> newRecords = allocateFromNumbers( prependNodeId( nodeRecord.getLongId(),
new long[]{42l} ),
iterator( record ), new PreAllocatedRecords( 60 ) );
nodeRecord.setLabelField( dynamicPointer( newRecords ), newRecords );
tx.create( nodeRecord );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
@Test
public void shouldNotReportAnythingForNodeWithConsistentChainOfDynamicRecordsWithLabels() throws Exception
{
// given
assertEquals( 3, chainOfDynamicRecordsWithLabelsForANode( 130 ).first().size() );
// when
ConsistencySummaryStatistics stats = check();
// then
assertTrue( "should be consistent", stats.isConsistent() );
}
@Test @Ignore("2013-07-17 Revisit once we store sorted label ids")
public void shouldReportOrphanNodeDynamicLabelAsInconsistency() throws Exception
{
// given
final List<DynamicRecord> chain = chainOfDynamicRecordsWithLabelsForANode( 130 ).first();
assertEquals( 3, chain.size() );
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord record1 = inUse( new DynamicRecord( chain.get( 0 ).getId() ) );
DynamicRecord record2 = notInUse( new DynamicRecord( chain.get( 1 ).getId() ) );
long[] data = (long[]) getRightArray( readFullByteArrayFromHeavyRecords( chain, ARRAY ) );
PreAllocatedRecords allocator = new PreAllocatedRecords( 60 );
allocateFromNumbers( Arrays.copyOf( data, 11 ), iterator( record1 ), allocator );
NodeRecord before = inUse( new NodeRecord( data[0], -1, -1 ) );
NodeRecord after = inUse( new NodeRecord( data[0], -1, -1 ) );
before.setLabelField( dynamicPointer( asList( record1 ) ), chain );
after.setLabelField( dynamicPointer( asList( record1 ) ), asList( record1, record2 ) );
tx.update( before, after );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE_DYNAMIC_LABEL );
}
@Test
public void shouldReportLabelScanStoreInconsistencies() throws Exception
{
// given
GraphStoreFixture.IdGenerator idGenerator = fixture.idGenerator();
long nodeId1 = idGenerator.node();
long labelId = idGenerator.label() - 1;
LabelScanStore labelScanStore = fixture.directStoreAccess().labelScanStore();
Iterable<NodeLabelUpdate> nodeLabelUpdates = asIterable(
labelChanges( nodeId1, new long[]{}, new long[]{labelId} )
);
write( labelScanStore, nodeLabelUpdates );
// when
ConsistencySummaryStatistics result = check();
// then
verifyInconsistency( result, RecordType.LABEL_SCAN_DOCUMENT );
}
private void write( LabelScanStore labelScanStore, Iterable<NodeLabelUpdate> nodeLabelUpdates ) throws IOException
{
try ( LabelScanWriter writer = labelScanStore.newWriter() )
{
for ( NodeLabelUpdate update : nodeLabelUpdates )
{
writer.write( update );
}
}
}
@Test
public void shouldReportIndexInconsistencies() throws Exception
{
// given
for ( Long indexedNodeId : indexedNodes )
{
fixture.directStoreAccess().nativeStores().getNodeStore().forceUpdateRecord( new NodeRecord( indexedNodeId, -1, -1 ) );
}
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.INDEX, RecordType.LABEL_SCAN_DOCUMENT );
}
@Test
public void shouldNotReportIndexInconsistenciesIfIndexIsFailed() throws Exception
{
// this test fails all indexes, and then destroys a record and makes sure we only get a failure for
// the label scan store but not for any index
// given
DirectStoreAccess storeAccess = fixture.directStoreAccess();
// fail all indexes
Iterator<IndexRule> rules = new SchemaStorage( storeAccess.nativeStores().getSchemaStore() ).allIndexRules();
while ( rules.hasNext() )
{
IndexRule rule = rules.next();
IndexDescriptor descriptor = new IndexDescriptor( rule.getLabel(), rule.getPropertyKey() );
IndexPopulator populator =
storeAccess.indexes().getPopulator( rule.getId(), descriptor, new IndexConfiguration( false ) );
populator.markAsFailed( "Oh noes! I was a shiny index and then I was failed" );
populator.close( false );
}
for ( Long indexedNodeId : indexedNodes )
{
storeAccess.nativeStores().getNodeStore().forceUpdateRecord( new NodeRecord( indexedNodeId, -1, -1 ) );
}
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.LABEL_SCAN_DOCUMENT );
}
@Test
public void shouldReportMismatchedLabels() throws Exception
{
final List<Integer> labels = new ArrayList<>();
// given
final Pair<List<DynamicRecord>, List<Integer>> pair = chainOfDynamicRecordsWithLabelsForANode( 3 );
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NodeRecord node = new NodeRecord( 42, -1, -1 );
node.setInUse( true );
List<DynamicRecord> dynamicRecords;
dynamicRecords = pair.first();
labels.addAll( pair.other() );
node.setLabelField( dynamicPointer( dynamicRecords ), dynamicRecords );
tx.create( node );
}
} );
long[] before = asArray( labels );
labels.remove( 1 );
long[] after = asArray( labels );
write( fixture.directStoreAccess().labelScanStore(), asList( labelChanges( 42, before, after ) ) );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
private long[] asArray(List<Integer> in){
long[] longs = new long[in.size()];
for ( int i = 0; i<in.size(); i++)
{
longs[i] = in.get( i ).longValue();
}
return longs;
}
@Test
public void shouldReportMismatchedInlinedLabels() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NodeRecord node = new NodeRecord( 42, -1, -1 );
node.setInUse( true );
node.setLabelField( inlinedLabelsLongRepresentation( 1, 2 ), Collections.<DynamicRecord>emptySet() );
tx.create( node );
}
} );
write( fixture.directStoreAccess().labelScanStore(), asList( labelChanges( 42, new long[]{1L, 2L}, new long[]{1L} ) ) );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
@Test
public void shouldReportNodesThatAreNotIndexed() throws Exception
{
// given
for ( IndexRule indexRule : loadAllIndexRules( fixture.directStoreAccess().nativeStores().getSchemaStore() ) )
{
IndexAccessor accessor = fixture.directStoreAccess().indexes().getOnlineAccessor( indexRule.getId(),
new IndexConfiguration( indexRule.isConstraintIndex() ) );
IndexUpdater updater = accessor.newUpdater( IndexUpdateMode.ONLINE );
updater.remove( indexedNodes );
updater.close();
accessor.close();
}
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
@Test
public void shouldReportNodesWithDuplicatePropertyValueInUniqueIndex() throws Exception
{
// given
for ( IndexRule indexRule : loadAllIndexRules( fixture.directStoreAccess().nativeStores().getSchemaStore() ) )
{
IndexAccessor accessor = fixture.directStoreAccess().indexes().getOnlineAccessor( indexRule.getId(),
new IndexConfiguration( false ) );
IndexUpdater updater = accessor.newUpdater( IndexUpdateMode.ONLINE );
updater.process( NodePropertyUpdate.add( 42, 0, "value", new long[]{3} ) );
updater.close();
accessor.close();
}
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE, RecordType.INDEX );
}
private long inlinedLabelsLongRepresentation( long... labelIds )
{
long header = (long)labelIds.length << 36;
byte bitsPerLabel = (byte) (36/labelIds.length);
Bits bits = bits( 5 );
for ( long labelId : labelIds )
{
bits.put( labelId, bitsPerLabel );
}
return header|bits.getLongs()[0];
}
@Test
public void shouldReportCyclesInDynamicRecordsWithLabels() throws Exception
{
// given
final List<DynamicRecord> chain = chainOfDynamicRecordsWithLabelsForANode( 176/*3 full records*/ ).first();
assertEquals( "number of records in chain", 3, chain.size() );
assertEquals( "all records full", chain.get( 0 ).getLength(), chain.get( 2 ).getLength() );
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
long nodeId = ((long[]) getRightArray( readFullByteArrayFromHeavyRecords( chain, ARRAY ) ))[0];
NodeRecord before = inUse( new NodeRecord( nodeId, -1, -1 ) );
NodeRecord after = inUse( new NodeRecord( nodeId, -1, -1 ) );
DynamicRecord record1 = chain.get( 0 ).clone();
DynamicRecord record2 = chain.get( 1 ).clone();
DynamicRecord record3 = chain.get( 2 ).clone();
record3.setNextBlock( record2.getId() );
before.setLabelField( dynamicPointer( chain ), chain );
after.setLabelField( dynamicPointer( chain ), asList( record1, record2, record3 ) );
tx.update( before, after );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
private Pair<List<DynamicRecord>, List<Integer>> chainOfDynamicRecordsWithLabelsForANode( int labelCount ) throws IOException
{
final long[] labels = new long[labelCount+1]; // allocate enough labels to need three records
final List<Integer> createdLabels = new ArrayList<>( );
for ( int i = 1/*leave space for the node id*/; i < labels.length; i++ )
{
final int offset = i;
fixture.apply( new GraphStoreFixture.Transaction()
{ // Neo4j can create no more than one label per transaction...
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
Integer label = next.label();
tx.nodeLabel( (int) (labels[offset] = label), "label:" + offset );
createdLabels.add( label );
}
} );
}
final List<DynamicRecord> chain = new ArrayList<>();
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NodeRecord nodeRecord = new NodeRecord( next.node(), -1, -1 );
DynamicRecord record1 = inUse( new DynamicRecord( next.nodeLabel() ) );
DynamicRecord record2 = inUse( new DynamicRecord( next.nodeLabel() ) );
DynamicRecord record3 = inUse( new DynamicRecord( next.nodeLabel() ) );
labels[0] = nodeRecord.getLongId(); // the first id should not be a label id, but the id of the node
PreAllocatedRecords allocator = new PreAllocatedRecords( 60 );
chain.addAll( allocateFromNumbers(
labels, iterator( record1, record2, record3 ), allocator ) );
nodeRecord.setLabelField( dynamicPointer( chain ), chain );
tx.create( nodeRecord );
}
} );
return Pair.of( chain, createdLabels );
}
@Test
public void shouldReportNodeDynamicLabelContainingDuplicateLabelAsNodeInconsistency() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
tx.nodeLabel( 42, "Label" );
NodeRecord nodeRecord = new NodeRecord( next.node(), -1, -1 );
DynamicRecord record = inUse( new DynamicRecord( next.nodeLabel() ) );
Collection<DynamicRecord> newRecords = allocateFromNumbers(
prependNodeId( nodeRecord.getLongId(), new long[]{42l, 42l} ),
iterator( record ), new PreAllocatedRecords( 60 ) );
nodeRecord.setLabelField( dynamicPointer( newRecords ), newRecords );
tx.create( nodeRecord );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE );
}
@Test
public void shouldReportOrphanedNodeDynamicLabelAsNodeInconsistency() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
tx.nodeLabel( 42, "Label" );
NodeRecord nodeRecord = new NodeRecord( next.node(), -1, -1 );
DynamicRecord record = inUse( new DynamicRecord( next.nodeLabel() ) );
Collection<DynamicRecord> newRecords = allocateFromNumbers( prependNodeId( next.node(), new long[]{42l} ),
iterator( record ), new PreAllocatedRecords( 60 ) );
nodeRecord.setLabelField( dynamicPointer( newRecords ), newRecords );
tx.create( nodeRecord );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.NODE_DYNAMIC_LABEL );
}
@Test
public void shouldReportRelationshipInconsistencies() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
tx.create( new RelationshipRecord( next.relationship(), 1, 2, 0 ) );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.RELATIONSHIP );
}
@Test
public void shouldReportPropertyInconsistencies() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
PropertyRecord property = new PropertyRecord( next.property() );
property.setPrevProp( next.property() );
PropertyBlock block = new PropertyBlock();
block.setSingleBlock( 1 | (((long) PropertyType.INT.intValue()) << 24) | (666 << 28) );
property.addPropertyBlock( block );
tx.create( property );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.PROPERTY );
}
@Test
public void shouldReportStringPropertyInconsistencies() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord string = new DynamicRecord( next.stringProperty() );
string.setInUse( true );
string.setCreated();
string.setType( PropertyType.STRING.intValue() );
string.setNextBlock( next.stringProperty() );
string.setData( UTF8.encode( "hello world" ) );
PropertyBlock block = new PropertyBlock();
block.setSingleBlock( (((long) PropertyType.STRING.intValue()) << 24) | (string.getId() << 28) );
block.addValueRecord( string );
PropertyRecord property = new PropertyRecord( next.property() );
property.addPropertyBlock( block );
tx.create( property );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.STRING_PROPERTY );
}
@Test
public void shouldReportBrokenSchemaRecordChain() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord schema = new DynamicRecord( next.schema() );
DynamicRecord schemaBefore = schema.clone();
schema.setNextBlock( next.schema() ); // Point to a record that isn't in use.
IndexRule rule = IndexRule.indexRule( 1, 1, 1,
new SchemaIndexProvider.Descriptor( "lucene", "1.0" ) );
schema.setData( new RecordSerializer().append( rule ).serialize() );
tx.createSchema( asList( schemaBefore ), asList( schema ) );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.SCHEMA );
}
@Test
public void shouldReportDuplicateConstraintReferences() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
int ruleId1 = (int) next.schema();
int ruleId2 = (int) next.schema();
int labelId = next.label();
int propertyKeyId = next.propertyKey();
DynamicRecord record1 = new DynamicRecord( ruleId1 );
DynamicRecord record2 = new DynamicRecord( ruleId2 );
DynamicRecord record1Before = record1.clone();
DynamicRecord record2Before = record2.clone();
SchemaIndexProvider.Descriptor providerDescriptor = new SchemaIndexProvider.Descriptor( "lucene", "1.0" );
IndexRule rule1 = IndexRule.constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor,
(long) ruleId1 );
IndexRule rule2 = IndexRule.constraintIndexRule( ruleId2, labelId, propertyKeyId, providerDescriptor, (long) ruleId1 );
Collection<DynamicRecord> records1 = serializeRule( rule1, record1 );
Collection<DynamicRecord> records2 = serializeRule( rule2, record2 );
assertEquals( asList( record1 ), records1 );
assertEquals( asList( record2 ), records2 );
tx.nodeLabel( labelId, "label" );
tx.propertyKey( propertyKeyId, "property" );
tx.createSchema( asList(record1Before), records1 );
tx.createSchema( asList(record2Before), records2 );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.SCHEMA );
}
@Test
public void shouldReportInvalidConstraintBackReferences() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
int ruleId1 = (int) next.schema();
int ruleId2 = (int) next.schema();
int labelId = next.label();
int propertyKeyId = next.propertyKey();
DynamicRecord record1 = new DynamicRecord( ruleId1 );
DynamicRecord record2 = new DynamicRecord( ruleId2 );
DynamicRecord record1Before = record1.clone();
DynamicRecord record2Before = record2.clone();
SchemaIndexProvider.Descriptor providerDescriptor = new SchemaIndexProvider.Descriptor( "lucene", "1.0" );
IndexRule rule1 = IndexRule.constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId2 );
UniquenessConstraintRule rule2 = UniquenessConstraintRule.uniquenessConstraintRule( ruleId2, labelId, propertyKeyId, ruleId2 );
Collection<DynamicRecord> records1 = serializeRule( rule1, record1 );
Collection<DynamicRecord> records2 = serializeRule( rule2, record2 );
assertEquals( asList( record1 ), records1 );
assertEquals( asList( record2 ), records2 );
tx.nodeLabel( labelId, "label" );
tx.propertyKey( propertyKeyId, "property" );
tx.createSchema( asList(record1Before), records1 );
tx.createSchema( asList(record2Before), records2 );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.SCHEMA );
}
public static Collection<DynamicRecord> serializeRule( SchemaRule rule, DynamicRecord... records )
{
return serializeRule( rule, asList( records ) );
}
public static Collection<DynamicRecord> serializeRule( SchemaRule rule, Collection<DynamicRecord> records )
{
RecordSerializer serializer = new RecordSerializer();
serializer.append( rule );
byte[] data = serializer.serialize();
PreAllocatedRecords dynamicRecordAllocator = new PreAllocatedRecords( data.length );
return AbstractDynamicStore.allocateRecordsFromBytes( data, records.iterator(), dynamicRecordAllocator );
}
@Test
public void shouldReportArrayPropertyInconsistencies() throws Exception
{
// given
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord array = new DynamicRecord( next.arrayProperty() );
array.setInUse( true );
array.setCreated();
array.setType( ARRAY.intValue() );
array.setNextBlock( next.arrayProperty() );
array.setData( UTF8.encode( "hello world" ) );
PropertyBlock block = new PropertyBlock();
block.setSingleBlock( (((long) ARRAY.intValue()) << 24) | (array.getId() << 28) );
block.addValueRecord( array );
PropertyRecord property = new PropertyRecord( next.property() );
property.addPropertyBlock( block );
tx.create( property );
}
} );
// when
ConsistencySummaryStatistics stats = check();
// then
verifyInconsistency( stats, RecordType.ARRAY_PROPERTY );
}
@Test
public void shouldReportRelationshipLabelNameInconsistencies() throws Exception
{
// given
final Reference<Integer> inconsistentName = new Reference<>();
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
inconsistentName.set( next.relationshipType() );
tx.relationshipType( inconsistentName.get(), "FOO" );
}
} );
StoreAccess access = fixture.directStoreAccess().nativeStores();
DynamicRecord record = access.getRelationshipTypeNameStore().forceGetRecord( inconsistentName.get() );
record.setNextBlock( record.getId() );
access.getRelationshipTypeNameStore().updateRecord( record );
// when
ConsistencySummaryStatistics stats = check( fixture.directStoreAccess() );
// then
verifyInconsistency( stats, RecordType.RELATIONSHIP_TYPE_NAME );
}
@Test
public void shouldReportPropertyKeyNameInconsistencies() throws Exception
{
// given
final Reference<Integer> inconsistentName = new Reference<>();
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
inconsistentName.set( next.propertyKey() );
tx.propertyKey( inconsistentName.get(), "FOO" );
}
} );
StoreAccess access = fixture.directStoreAccess().nativeStores();
DynamicRecord record = access.getPropertyKeyNameStore().forceGetRecord( inconsistentName.get() );
record.setNextBlock( record.getId() );
access.getPropertyKeyNameStore().updateRecord( record );
// when
ConsistencySummaryStatistics stats = check( fixture.directStoreAccess() );
// then
verifyInconsistency( stats, RecordType.PROPERTY_KEY_NAME );
}
@Test
public void shouldReportRelationshipTypeInconsistencies() throws Exception
{
// given
StoreAccess access = fixture.directStoreAccess().nativeStores();
RecordStore<RelationshipTypeTokenRecord> relTypeStore = access.getRelationshipTypeTokenStore();
RelationshipTypeTokenRecord record = relTypeStore.forceGetRecord( relTypeStore.nextId() );
record.setNameId( 20 );
record.setInUse( true );
relTypeStore.updateRecord( record );
// when
ConsistencySummaryStatistics stats = check( fixture.directStoreAccess() );
// then
verifyInconsistency( stats, RecordType.RELATIONSHIP_TYPE );
}
@Test
public void shouldReportLabelInconsistencies() throws Exception
{
// given
StoreAccess access = fixture.directStoreAccess().nativeStores();
LabelTokenRecord record = access.getLabelTokenStore().forceGetRecord( 1 );
record.setNameId( 20 );
record.setInUse( true );
access.getLabelTokenStore().updateRecord( record );
// when
ConsistencySummaryStatistics stats = check( fixture.directStoreAccess() );
// then
verifyInconsistency( stats, RecordType.LABEL );
}
@Test
public void shouldReportPropertyKeyInconsistencies() throws Exception
{
// given
final Reference<Integer> inconsistentKey = new Reference<>();
fixture.apply( new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
inconsistentKey.set( next.propertyKey() );
tx.propertyKey( inconsistentKey.get(), "FOO" );
}
} );
StoreAccess access = fixture.directStoreAccess().nativeStores();
DynamicRecord record = access.getPropertyKeyNameStore().forceGetRecord( inconsistentKey.get() );
record.setInUse( false );
access.getPropertyKeyNameStore().updateRecord( record );
// when
ConsistencySummaryStatistics stats = check( fixture.directStoreAccess() );
// then
verifyInconsistency( stats, RecordType.PROPERTY_KEY );
}
private static class Reference<T>
{
private T value;
void set(T value)
{
this.value = value;
}
T get()
{
return value;
}
@Override
public String toString()
{
return String.valueOf( value );
}
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_FullCheckIntegrationTest.java
|
4,186
|
{
@Override
RecordReference<NeoStoreRecord> record( RecordAccess records )
{
return records.graph();
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_PropertyOwner.java
|
4,187
|
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord schema = new DynamicRecord( next.schema() );
DynamicRecord before = schema.clone();
schema.setNextBlock( next.schema() );
IndexRule rule = IndexRule.indexRule( 1, 1, 1, new SchemaIndexProvider.Descriptor( "in-memory",
"1.0" ) );
new RecordSerializer().append( rule ).serialize();
schema.setData( new RecordSerializer().append( rule ).serialize() );
tx.createSchema( asList(before), asList( schema ) );
}
} );
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_incremental_IncrementalCheckIntegrationTest.java
|
4,188
|
public class IncrementalCheckIntegrationTest
{
@Test
public void shouldReportBrokenSchemaRecordChain() throws Exception
{
verifyInconsistencyReported( RecordType.SCHEMA, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord schema = new DynamicRecord( next.schema() );
DynamicRecord before = schema.clone();
schema.setNextBlock( next.schema() );
IndexRule rule = IndexRule.indexRule( 1, 1, 1, new SchemaIndexProvider.Descriptor( "in-memory",
"1.0" ) );
new RecordSerializer().append( rule ).serialize();
schema.setData( new RecordSerializer().append( rule ).serialize() );
tx.createSchema( asList(before), asList( schema ) );
}
} );
}
@Test
public void shouldReportDuplicateConstraintReferences() throws Exception
{
verifyInconsistencyReported( RecordType.SCHEMA, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
int ruleId1 = (int) next.schema();
int ruleId2 = (int) next.schema();
int labelId = (int) next.label();
int propertyKeyId = next.propertyKey();
DynamicRecord record1 = new DynamicRecord( ruleId1 );
DynamicRecord record2 = new DynamicRecord( ruleId2 );
DynamicRecord record1Before = record1.clone();
DynamicRecord record2Before = record2.clone();
SchemaIndexProvider.Descriptor providerDescriptor = new SchemaIndexProvider.Descriptor( "in-memory", "1.0" );
IndexRule rule1 = IndexRule.constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor, (long) ruleId1);
IndexRule rule2 = IndexRule.constraintIndexRule( ruleId2, labelId, propertyKeyId, providerDescriptor, (long) ruleId1);
Collection<DynamicRecord> records1 = serializeRule( rule1, record1 );
Collection<DynamicRecord> records2 = serializeRule( rule2, record2 );
assertEquals( asList( record1 ), records1 );
assertEquals( asList( record2 ), records2 );
tx.nodeLabel( labelId, "label" );
tx.propertyKey( propertyKeyId, "property" );
tx.createSchema( asList(record1Before), records1 );
tx.createSchema( asList(record2Before), records2 );
}
} );
}
@Test
public void shouldReportInvalidConstraintBackReferences() throws Exception
{
verifyInconsistencyReported( RecordType.SCHEMA, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
int ruleId1 = (int) next.schema();
int ruleId2 = (int) next.schema();
int labelId = (int) next.label();
int propertyKeyId = next.propertyKey();
DynamicRecord record1 = new DynamicRecord( ruleId1 );
DynamicRecord record2 = new DynamicRecord( ruleId2 );
DynamicRecord record1Before = record1.clone();
DynamicRecord record2Before = record2.clone();
SchemaIndexProvider.Descriptor providerDescriptor = new SchemaIndexProvider.Descriptor( "in-memory",
"1.0" );
IndexRule rule1 = IndexRule.constraintIndexRule( ruleId1, labelId, propertyKeyId, providerDescriptor,
(long) ruleId2 );
UniquenessConstraintRule rule2 = UniquenessConstraintRule.uniquenessConstraintRule( ruleId2, labelId,
propertyKeyId, ruleId2 );
Collection<DynamicRecord> records1 = serializeRule( rule1, record1 );
Collection<DynamicRecord> records2 = serializeRule( rule2, record2 );
assertEquals( asList( record1 ), records1 );
assertEquals( asList( record2 ), records2 );
tx.nodeLabel( labelId, "label" );
tx.propertyKey( propertyKeyId, "property" );
tx.createSchema( asList(record1Before), records1 );
tx.createSchema( asList(record2Before), records2 );
}
} );
}
@Test
@Ignore("Support for checking NeoStore needs to be added")
public void shouldReportNeoStoreInconsistencies() throws Exception
{
verifyInconsistencyReported( RecordType.NEO_STORE, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
NeoStoreRecord record = new NeoStoreRecord();
record.setNextProp( next.property() );
tx.update( record );
// We get exceptions when only the above happens in a transaction...
tx.create( new NodeRecord( next.node(), -1, -1 ) );
}
} );
}
@Test
public void shouldReportNodeInconsistency() throws Exception
{
verifyInconsistencyReported( RecordType.NODE, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
tx.create( new NodeRecord( next.node(), next.relationship(), -1 ) );
}
} );
}
@Test
public void shouldReportRelationshipInconsistency() throws Exception
{
verifyInconsistencyReported( RecordType.RELATIONSHIP, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
long node = next.node();
tx.create( new RelationshipRecord( next.relationship(), node, node, 0 ) );
}
} );
}
@Test
public void shouldReportPropertyInconsistency() throws Exception
{
verifyInconsistencyReported( RecordType.PROPERTY, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
PropertyRecord property = new PropertyRecord( next.property() );
property.setPrevProp( next.property() );
property.setNodeId( 1 );
PropertyBlock block = new PropertyBlock();
block.setSingleBlock( (((long) PropertyType.INT.intValue()) << 24) | (666 << 28) );
property.addPropertyBlock( block );
tx.create( property );
}
} );
}
@Test
public void shouldReportStringPropertyInconsistency() throws Exception
{
verifyInconsistencyReported( RecordType.STRING_PROPERTY, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord string = new DynamicRecord( next.stringProperty() );
string.setInUse( true );
string.setCreated();
string.setType( PropertyType.STRING.intValue() );
string.setNextBlock( next.stringProperty() );
string.setData( UTF8.encode( "hello world" ) );
PropertyBlock block = new PropertyBlock();
block.setSingleBlock( (((long) PropertyType.STRING.intValue()) << 24) | (string.getId() << 28) );
block.addValueRecord( string );
PropertyRecord property = new PropertyRecord( next.property() );
property.addPropertyBlock( block );
NodeRecord node = new NodeRecord( next.node(), -1, property.getId() );
property.setNodeId( node.getId() );
tx.create( node );
tx.create( property );
}
} );
}
@Test
public void shouldReportArrayPropertyInconsistency() throws Exception
{
verifyInconsistencyReported( RecordType.ARRAY_PROPERTY, new GraphStoreFixture.Transaction()
{
@Override
protected void transactionData( GraphStoreFixture.TransactionDataBuilder tx,
GraphStoreFixture.IdGenerator next )
{
DynamicRecord array = new DynamicRecord( next.arrayProperty() );
array.setInUse( true );
array.setCreated();
array.setType( PropertyType.ARRAY.intValue() );
array.setNextBlock( next.arrayProperty() );
array.setData( UTF8.encode( "hello world" ) );
PropertyBlock block = new PropertyBlock();
block.setSingleBlock( (((long) PropertyType.ARRAY.intValue()) << 24) | (array.getId() << 28) );
block.addValueRecord( array );
PropertyRecord property = new PropertyRecord( next.property() );
property.addPropertyBlock( block );
NodeRecord node = new NodeRecord( next.node(), -1, property.getId() );
property.setNodeId( node.getId() );
tx.create( node );
tx.create( property );
}
} );
}
private static String LONG_STRING, LONG_SHORT_STRING;
static
{
StringBuilder longString = new StringBuilder();
String longShortString = "";
for ( int i = 0; LongerShortString.encode( 0, longString.toString(), new PropertyBlock(),
PropertyType.getPayloadSize() ); i++ )
{
longShortString = longString.toString();
longString.append( 'a' + (i % ('z' - 'a')) );
}
LONG_SHORT_STRING = longShortString;
LONG_STRING = longString.toString();
}
@Rule
public final GraphStoreFixture fixture = new GraphStoreFixture()
{
@Override
protected void generateInitialData( GraphDatabaseService graphDb )
{
org.neo4j.graphdb.Transaction tx = graphDb.beginTx();
try
{
Node node1 = set( graphDb.createNode(),
property( "long short short", LONG_SHORT_STRING ) );
Node node2 = set( graphDb.createNode(),
property( "long string", LONG_STRING ) );
Node node3 = set( graphDb.createNode(),
property( "one", "1" ),
property( "two", "2" ),
property( "three", "3" ),
property( "four", "4" ),
property( "five", "5" ) );
Node node4 = set( graphDb.createNode(),
property( "name", "Leeloo Dallas" ) );
Node node5 = set( graphDb.createNode(),
property( "payload", LONG_SHORT_STRING ),
property( "more", LONG_STRING ) );
Node node6 = set( graphDb.createNode() );
set( node1.createRelationshipTo( node2, withName( "WHEEL" ) ) );
set( node2.createRelationshipTo( node3, withName( "WHEEL" ) ) );
set( node3.createRelationshipTo( node4, withName( "WHEEL" ) ) );
set( node4.createRelationshipTo( node5, withName( "WHEEL" ) ) );
set( node5.createRelationshipTo( node1, withName( "WHEEL" ) ) );
set( node6.createRelationshipTo( node1, withName( "STAR" ) ) );
set( node6.createRelationshipTo( node2, withName( "STAR" ) ) );
set( node6.createRelationshipTo( node3, withName( "STAR" ) ) );
set( node6.createRelationshipTo( node4, withName( "STAR" ) ) );
set( node6.createRelationshipTo( node5, withName( "STAR" ) ) );
tx.success();
}
finally
{
tx.finish();
}
}
@Override
protected Map<String, String> configuration( boolean initialData )
{
Map<String, String> config = super.configuration( initialData );
if ( !initialData )
{
config.put( GraphDatabaseSettings.intercept_deserialized_transactions.name(), "true" );
config.put( GraphDatabaseSettings.intercept_committing_transactions.name(), "true" );
config.put( TransactionInterceptorProvider.class.getSimpleName() + "." +
VerifyingTransactionInterceptorProvider.NAME, "true" );
}
return config;
}
};
private void verifyInconsistencyReported( RecordType recordType,
GraphStoreFixture.Transaction inconsistentTransaction )
throws IOException
{
// when
try
{
fixture.apply( inconsistentTransaction );
fail( "should have thrown error" );
}
// then
catch ( ConsistencyCheckingError expected )
{
int count = expected.getInconsistencyCountForRecordType( recordType );
int total = expected.getTotalInconsistencyCount();
String summary = expected.getMessage().replace( "\n", "\n\t" );
assertTrue( "Expected failures for " + recordType + ", got " + summary, count > 0 );
assertEquals( "Didn't expect failures for any other type than " + recordType + ", got " + summary,
count, total );
}
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_incremental_IncrementalCheckIntegrationTest.java
|
4,189
|
public class FullDiffCheck extends DiffCheck
{
public FullDiffCheck( StringLogger logger )
{
super( logger );
}
@Override
public ConsistencySummaryStatistics execute( DiffStore diffs ) throws ConsistencyCheckIncompleteException
{
Config tuningConfiguration = new Config( stringMap(), GraphDatabaseSettings.class,
ConsistencyCheckSettings.class );
String storeDir = tuningConfiguration.get( GraphDatabaseSettings.store_dir ).getAbsolutePath();
DefaultFileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction();
LabelScanStore labelScanStore =
new LuceneLabelScanStoreBuilder( storeDir, diffs.getRawNeoStore(), fileSystem, logger ).build();
SchemaIndexProvider indexes = new LuceneSchemaIndexProvider( DirectoryFactory.PERSISTENT, tuningConfiguration );
DirectStoreAccess stores = new DirectStoreAccess( diffs, labelScanStore, indexes );
return new FullCheck( tuningConfiguration, ProgressMonitorFactory.NONE ).execute( stores, logger );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_incremental_FullDiffCheck.java
|
4,190
|
public abstract class DiffCheck
{
final StringLogger logger;
public DiffCheck( StringLogger logger )
{
this.logger = logger;
}
public final void check( DiffStore diffs ) throws InconsistentStoreException, ConsistencyCheckIncompleteException
{
verify( diffs, execute( diffs ) );
}
public abstract ConsistencySummaryStatistics execute( DiffStore diffs )
throws ConsistencyCheckIncompleteException;
protected void verify( DiffStore diffs, ConsistencySummaryStatistics summary )
throws InconsistentStoreException
{
if ( !summary.isConsistent() )
{
throw new InconsistentStoreException( summary );
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_incremental_DiffCheck.java
|
4,191
|
MULTI_PASS
{
@Override
void execute( List<StoppableRunnable> tasks, Completion completion )
throws ConsistencyCheckIncompleteException
{
try
{
for ( StoppableRunnable task : tasks )
{
task.run();
}
completion.await( 0, TimeUnit.SECONDS );
}
catch ( Exception e )
{
throw new ConsistencyCheckIncompleteException( e );
}
}
};
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_TaskExecutionOrder.java
|
4,192
|
SINGLE_THREADED
{
@Override
void execute( List<StoppableRunnable> tasks, Completion completion )
throws ConsistencyCheckIncompleteException
{
try
{
for ( StoppableRunnable task : tasks )
{
task.run();
}
completion.await( 0, TimeUnit.SECONDS );
}
catch ( Exception e )
{
throw new ConsistencyCheckIncompleteException( e );
}
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_TaskExecutionOrder.java
|
4,193
|
MULTI_THREADED
{
@Override
void execute( List<StoppableRunnable> tasks, Completion completion )
throws ConsistencyCheckIncompleteException
{
ExecutorService executor = Executors.newFixedThreadPool( Runtime.getRuntime().availableProcessors() );
for ( StoppableRunnable task : tasks )
{
executor.submit( task );
}
try
{
completion.await( 7, TimeUnit.DAYS );
}
catch ( Exception e )
{
tasks.get( 0 ).stopScanning();
throw new ConsistencyCheckIncompleteException( e );
}
finally
{
executor.shutdown();
try
{
executor.awaitTermination( 10, TimeUnit.SECONDS );
}
catch ( InterruptedException e )
{
// don't care
}
}
}
},
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_TaskExecutionOrder.java
|
4,194
|
{
@Override
public NodeRecord answer( InvocationOnMock invocation ) throws Throwable
{
processor.stopScanning();
return new NodeRecord( 0, 0, 0 );
}
} );
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_StoreProcessorTest.java
|
4,195
|
public class StoreProcessorTest
{
@SuppressWarnings("unchecked")
@Test
public void shouldProcessAllTheRecordsInAStore() throws Exception
{
// given
StoreProcessor processor = new StoreProcessor( CheckDecorator.NONE, mock( ConsistencyReport.Reporter.class ) );
RecordStore recordStore = mock( RecordStore.class );
when( recordStore.getHighId() ).thenReturn( 3L );
when( recordStore.forceGetRecord( any( Long.class ) ) ).thenReturn( new NodeRecord( 0, 0, 0 ) );
// when
processor.applyFiltered( recordStore );
// then
verify( recordStore ).forceGetRecord( 0 );
verify( recordStore ).forceGetRecord( 1 );
verify( recordStore ).forceGetRecord( 2 );
verify( recordStore, never() ).forceGetRecord( 3 );
}
@SuppressWarnings("unchecked")
@Test
public void shouldStopProcessingRecordsWhenSignalledToStop() throws Exception
{
// given
final StoreProcessor processor = new StoreProcessor( CheckDecorator.NONE, mock( ConsistencyReport.Reporter.class ) );
RecordStore recordStore = mock( RecordStore.class );
when( recordStore.getHighId() ).thenReturn( 4L );
when( recordStore.forceGetRecord( 0L ) ).thenReturn( new NodeRecord( 0, 0, 0 ) );
when( recordStore.forceGetRecord( 1L ) ).thenReturn( new NodeRecord( 0, 0, 0 ) );
when( recordStore.forceGetRecord( 2L ) ).thenAnswer( new Answer<NodeRecord>()
{
@Override
public NodeRecord answer( InvocationOnMock invocation ) throws Throwable
{
processor.stopScanning();
return new NodeRecord( 0, 0, 0 );
}
} );
// when
processor.applyFiltered( recordStore );
// then
verify( recordStore ).forceGetRecord( 0 );
verify( recordStore ).forceGetRecord( 1 );
verify( recordStore ).forceGetRecord( 2 );
verify( recordStore, never() ).forceGetRecord( 3 );
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_StoreProcessorTest.java
|
4,196
|
@SuppressWarnings("unchecked")
public class StoreProcessorTaskTest
{
@Test
public void singlePassShouldOnlyProcessTheStoreOnce() throws Exception
{
// given
StoreProcessor singlePassProcessor = mock( StoreProcessor.class );
StoreProcessor multiPassProcessor1 = mock( StoreProcessor.class );
StoreProcessor multiPassProcessor2 = mock( StoreProcessor.class );
NodeStore store = mock( NodeStore.class );
when( store.getStorageFileName() ).thenReturn( new File("node-store") );
StoreProcessorTask<NodeRecord> task = new StoreProcessorTask<NodeRecord>(
store, ProgressMonitorFactory.NONE.multipleParts( "check" ), SINGLE_THREADED,
singlePassProcessor, multiPassProcessor1, multiPassProcessor2 );
// when
task.run();
// then
verify( singlePassProcessor ).applyFiltered( same( store ), any( ProgressListener.class ) );
verifyZeroInteractions( multiPassProcessor1, multiPassProcessor2 );
}
@Test
public void multiPassShouldProcessTheStoreOnceForEachOfTheSuppliedProcessors() throws Exception
{
// given
StoreProcessor singlePassProcessor = mock( StoreProcessor.class );
StoreProcessor multiPassProcessor1 = mock( StoreProcessor.class );
StoreProcessor multiPassProcessor2 = mock( StoreProcessor.class );
NodeStore store = mock( NodeStore.class );
when( store.getStorageFileName() ).thenReturn( new File("node-store") );
StoreProcessorTask<NodeRecord> task = new StoreProcessorTask<NodeRecord>(
store, ProgressMonitorFactory.NONE.multipleParts( "check" ), MULTI_PASS,
singlePassProcessor, multiPassProcessor1, multiPassProcessor2 );
// when
task.run();
// then
verify( multiPassProcessor1 ).applyFiltered( same( store ), any( ProgressListener.class ) );
verify( multiPassProcessor2 ).applyFiltered( same( store ), any( ProgressListener.class ) );
verifyZeroInteractions( singlePassProcessor );
}
@Test
public void multiPassShouldBuildProgressListenersForEachPass() throws Exception
{
// given
StoreProcessor multiPassProcessor1 = mock( StoreProcessor.class );
StoreProcessor multiPassProcessor2 = mock( StoreProcessor.class );
NodeStore store = mock( NodeStore.class );
when( store.getStorageFileName() ).thenReturn( new File("node-store") );
StoreProcessorTask<NodeRecord> task = new StoreProcessorTask<NodeRecord>(
store, ProgressMonitorFactory.NONE.multipleParts( "check" ), MULTI_PASS,
mock( StoreProcessor.class ), multiPassProcessor1, multiPassProcessor2 );
// when
task.run();
// then
ArgumentCaptor<ProgressListener> listener1 = ArgumentCaptor.forClass( ProgressListener.class );
ArgumentCaptor<ProgressListener> listener2 = ArgumentCaptor.forClass( ProgressListener.class );
verify( multiPassProcessor1 ).applyFiltered( same( store ), listener1.capture() );
verify( multiPassProcessor2 ).applyFiltered( same( store ), listener2.capture() );
assertNotSame(listener1.getValue(), listener2.getValue());
}
}
| false
|
enterprise_consistency-check_src_test_java_org_neo4j_consistency_checking_full_StoreProcessorTaskTest.java
|
4,197
|
class StoreProcessorTask<R extends AbstractBaseRecord> implements StoppableRunnable
{
private final RecordStore<R> store;
private final StoreProcessor[] processors;
private final ProgressListener[] progressListeners;
StoreProcessorTask( RecordStore<R> store,
ProgressMonitorFactory.MultiPartBuilder builder,
TaskExecutionOrder order, StoreProcessor singlePassProcessor,
StoreProcessor... multiPassProcessors )
{
this( store, "", builder, order, singlePassProcessor, multiPassProcessors );
}
StoreProcessorTask( RecordStore<R> store, String builderPrefix,
ProgressMonitorFactory.MultiPartBuilder builder,
TaskExecutionOrder order, StoreProcessor singlePassProcessor,
StoreProcessor... multiPassProcessors )
{
this.store = store;
String storeFileName = store.getStorageFileName().getName();
String sanitizedBuilderPrefix = builderPrefix == null ? "" : builderPrefix;
if ( order == TaskExecutionOrder.MULTI_PASS )
{
this.processors = multiPassProcessors;
this.progressListeners = new ProgressListener[multiPassProcessors.length];
for ( int i = 0; i < multiPassProcessors.length; i++ )
{
String partName = indexedPartName( storeFileName, sanitizedBuilderPrefix, i );
progressListeners[i] = builder.progressForPart( partName, store.getHighId() );
}
}
else
{
this.processors = new StoreProcessor[]{singlePassProcessor};
String partName = partName( storeFileName, sanitizedBuilderPrefix );
this.progressListeners = new ProgressListener[]{
builder.progressForPart( partName, store.getHighId() )};
}
}
private String partName( String storeFileName, String builderPrefix )
{
return builderPrefix.length() == 0 ? storeFileName : format("%s_run_%s", storeFileName, builderPrefix );
}
private String indexedPartName( String storeFileName, String prefix, int i )
{
if ( prefix.length() != 0 )
{
prefix += "_";
}
return format( "%s_pass_%s%d", storeFileName, prefix, i );
}
@SuppressWarnings("unchecked")
@Override
public void run()
{
for ( int i = 0; i < processors.length; i++ )
{
StoreProcessor processor = processors[i];
beforeProcessing(processor);
try
{
processor.applyFiltered( store, progressListeners[i] );
}
catch ( Throwable e )
{
progressListeners[i].failed( e );
}
finally
{
afterProcessing(processor);
}
}
}
protected void beforeProcessing( StoreProcessor processor )
{
// intentionally empty
}
protected void afterProcessing( StoreProcessor processor )
{
// intentionally empty
}
@Override
public void stopScanning()
{
processors[0].stopScanning();
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_StoreProcessorTask.java
|
4,198
|
class StoreProcessor extends AbstractStoreProcessor
{
private final ConsistencyReport.Reporter report;
private SchemaRecordCheck schemaRecordCheck;
public StoreProcessor( CheckDecorator decorator, ConsistencyReport.Reporter report )
{
super( decorator );
this.report = report;
this.schemaRecordCheck = null;
}
@SuppressWarnings("UnusedParameters")
protected void checkSchema( RecordType type, RecordStore<DynamicRecord> store, DynamicRecord schema, RecordCheck
<DynamicRecord, ConsistencyReport.SchemaConsistencyReport> checker )
{
report.forSchema( schema, checker );
}
@Override
protected void checkNode( RecordStore<NodeRecord> store, NodeRecord node,
RecordCheck<NodeRecord, ConsistencyReport.NodeConsistencyReport> checker )
{
report.forNode( node, checker );
}
@Override
protected void checkRelationship( RecordStore<RelationshipRecord> store, RelationshipRecord rel,
RecordCheck<RelationshipRecord, ConsistencyReport.RelationshipConsistencyReport> checker )
{
report.forRelationship( rel, checker );
}
@Override
protected void checkProperty( RecordStore<PropertyRecord> store, PropertyRecord property,
RecordCheck<PropertyRecord, ConsistencyReport.PropertyConsistencyReport> checker )
{
report.forProperty( property, checker );
}
@Override
protected void checkRelationshipTypeToken( RecordStore<RelationshipTypeTokenRecord> store,
RelationshipTypeTokenRecord relationshipType,
RecordCheck<RelationshipTypeTokenRecord,
ConsistencyReport.RelationshipTypeConsistencyReport> checker )
{
report.forRelationshipTypeName( relationshipType, checker );
}
@Override
protected void checkLabelToken( RecordStore<LabelTokenRecord> store, LabelTokenRecord label,
RecordCheck<LabelTokenRecord, ConsistencyReport.LabelTokenConsistencyReport>
checker )
{
report.forLabelName( label, checker );
}
@Override
protected void checkPropertyKeyToken( RecordStore<PropertyKeyTokenRecord> store, PropertyKeyTokenRecord key,
RecordCheck<PropertyKeyTokenRecord,
ConsistencyReport.PropertyKeyTokenConsistencyReport> checker )
{
report.forPropertyKey( key, checker );
}
@Override
protected void checkDynamic( RecordType type, RecordStore<DynamicRecord> store, DynamicRecord string,
RecordCheck<DynamicRecord, ConsistencyReport.DynamicConsistencyReport> checker )
{
report.forDynamicBlock( type, string, checker );
}
@Override
protected void checkDynamicLabel( RecordType type, RecordStore<DynamicRecord> store, DynamicRecord string,
RecordCheck<DynamicRecord, DynamicLabelConsistencyReport> checker )
{
report.forDynamicLabelBlock( type, string, checker );
}
void setSchemaRecordCheck( SchemaRecordCheck schemaRecordCheck )
{
this.schemaRecordCheck = schemaRecordCheck;
}
@Override
public void processSchema( RecordStore<DynamicRecord> store, DynamicRecord schema )
{
if ( null == schemaRecordCheck )
{
super.processSchema( store, schema );
}
else
{
checkSchema( RecordType.SCHEMA, store, schema, schemaRecordCheck );
}
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_StoreProcessor.java
|
4,199
|
public class SchemaStoreProcessorTask<R extends AbstractBaseRecord> extends StoreProcessorTask<R>
{
private final SchemaRecordCheck schemaRecordCheck;
public SchemaStoreProcessorTask( RecordStore<R> store,
String builderPrefix,
SchemaRecordCheck schemaRecordCheck,
ProgressMonitorFactory.MultiPartBuilder builder,
TaskExecutionOrder order, StoreProcessor singlePassProcessor, StoreProcessor...
multiPassProcessors )
{
super( store, builderPrefix, builder, order, singlePassProcessor, multiPassProcessors );
this.schemaRecordCheck = schemaRecordCheck;
}
@Override
protected void beforeProcessing( StoreProcessor processor )
{
processor.setSchemaRecordCheck( schemaRecordCheck );
}
@Override
protected void afterProcessing( StoreProcessor processor )
{
processor.setSchemaRecordCheck( null );
}
}
| false
|
enterprise_consistency-check_src_main_java_org_neo4j_consistency_checking_full_SchemaStoreProcessorTask.java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.