public IList <Org.Neo4j.Consistency.store.RecordAccess> MultiPassFilters(Org.Neo4j.Consistency.store.RecordAccess recordAccess, MultiPassStore[] stores)
{
IList <RecordAccess> filteringStores = new List <RecordAccess>();
filteringStores.Add(new FilteringRecordAccess(recordAccess, this, stores));
return(filteringStores);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @BeforeEach void setUp()
internal virtual void SetUp()
{
RecordAccess records = mock(typeof(RecordAccess));
ReportHandler handler = new ReportHandler(mock(typeof(InconsistencyReport)), mock(typeof(ConsistencyReporter.ProxyFactory)), RecordType.PROPERTY, records, new PropertyRecord(0), NO_MONITOR);
this._referenceCheck = new PendingReferenceCheck <PropertyRecord>(handler, mock(typeof(ComparativeRecordChecker)));
}
public override void Check(RECORD record, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
if (!record.inUse())
{
return;
}
foreach (RecordField <RECORD, REPORT> field in _fields)
{
field.CheckConsistency(record, engine, records);
}
}
public void CheckConsistency(Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord record, CheckerEngine <Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipGroupConsistencyReport> engine, Org.Neo4j.Consistency.store.RecordAccess records)
{
if (record.OwningNode < 0)
{
engine.Report().illegalOwner();
}
else
{
engine.ComparativeCheck(records.Node(record.OwningNode), this);
}
}
public void CheckReference(Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord record, Org.Neo4j.Kernel.impl.store.record.NodeRecord referred, CheckerEngine <Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipGroupConsistencyReport> engine, Org.Neo4j.Consistency.store.RecordAccess records)
{
if (!referred.InUse())
{
engine.Report().ownerNotInUse();
}
}
public void checkReference(Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord record, Org.Neo4j.Kernel.impl.store.record.RelationshipRecord referred, CheckerEngine <Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipGroupConsistencyReport> engine, Org.Neo4j.Consistency.store.RecordAccess records)
{
if (!referred.inUse())
{
relationshipNotInUse(engine.report());
}
else
{
if (!isFirstInChain(referred))
{
relationshipNotFirstInChain(engine.report());
}
if (referred.getType() != record.getType())
{
relationshipOfOtherType(engine.report());
}
}
}
public void CheckReference(Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord record, Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord referred, CheckerEngine <Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipGroupConsistencyReport> engine, Org.Neo4j.Consistency.store.RecordAccess records)
{
if (!referred.InUse())
{
engine.Report().nextGroupNotInUse();
}
else
{
if (record.Type >= referred.Type)
{
engine.Report().invalidTypeSortOrder();
}
if (record.OwningNode != referred.OwningNode)
{
engine.Report().nextHasOtherOwner(referred);
}
}
}
public override void CheckReference( DynamicRecord record, DynamicRecord record2, CheckerEngine<DynamicRecord, ConsistencyReport_DynamicLabelConsistencyReport> engine, RecordAccess records )
{
}
public virtual void CheckReference(REFERENCED referenced, RecordAccess records)
{
ConsistencyReporter.DispatchReference(Engine(), _checker, referenced, records);
}
public override void Check(IndexEntry record, CheckerEngine <IndexEntry, Org.Neo4j.Consistency.report.ConsistencyReport_IndexConsistencyReport> engine, RecordAccess records)
{
long id = record.Id;
switch (_entityType.innerEnumValue)
{
case EntityType.InnerEnum.NODE:
engine.ComparativeCheck(records.Node(id), _nodeChecker);
break;
case EntityType.InnerEnum.RELATIONSHIP:
if (_indexRule.canSupportUniqueConstraint())
{
engine.Report().relationshipConstraintIndex();
}
engine.ComparativeCheck(records.Relationship(id), _relationshipChecker);
break;
default:
throw new System.InvalidOperationException("Don't know how to check index entry of entity type " + _entityType);
}
}
public override void CheckReference(RECORD record, RelationshipRecord relationshipRecord, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
if (relationshipRecord.InUse())
{
// Relationship indexes are always semantically multi-token, which means that the relationship record just need to have one of the possible
// relationship types mentioned by the index. Relationships can't have more than one type anyway.
long type = relationshipRecord.Type;
if (Arrays.binarySearch(_indexRelationshipTypes, type) < 0)
{
// The relationship did not have any of the relationship types mentioned by the index.
foreach (long indexRelationshipType in _indexRelationshipTypes)
{
engine.Report().relationshipDoesNotHaveExpectedRelationshipType(relationshipRecord, indexRelationshipType);
}
}
}
else
{
engine.Report().relationshipNotInUse(relationshipRecord);
}
}
public abstract void Check(RECORD record, Org.Neo4j.Consistency.checking.CheckerEngine <RECORD, REPORT> engine, Org.Neo4j.Consistency.store.RecordAccess records);
public override void CheckReference(DynamicRecord record, DynamicRecord next, CheckerEngine <DynamicRecord, Org.Neo4j.Consistency.report.ConsistencyReport_DynamicConsistencyReport> engine, RecordAccess records)
{
if (!next.InUse())
{
engine.Report().nextNotInUse(next);
}
else
{
if (next.Length <= 0)
{
engine.Report().emptyNextBlock(next);
}
}
}
public override void Check(DynamicRecord record, CheckerEngine <DynamicRecord, Org.Neo4j.Consistency.report.ConsistencyReport_DynamicConsistencyReport> engine, RecordAccess records)
{
if (!record.InUse())
{
return;
}
if (record.Length == 0)
{
engine.Report().emptyBlock();
}
else if (record.Length < 0)
{
engine.Report().invalidLength();
}
if (!Record.NO_NEXT_BLOCK.@is(record.NextBlock))
{
if (record.NextBlock == record.Id)
{
engine.Report().selfReferentialNext();
}
else
{
engine.ComparativeCheck(_dereference.lookup(records, record.NextBlock), this);
}
if (record.Length < _blockSize)
{
engine.Report().recordNotFullReferencesNext();
}
}
}
public override void CheckReference(RECORD record, PropertyRecord property, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
foreach (int key in Keys(property))
{
if (!_keys.add(key))
{
engine.Report().propertyKeyNotUniqueInChain();
}
}
if (!Record.NO_NEXT_PROPERTY.@is(property.NextProp))
{
engine.ComparativeCheck(records.Property(property.NextProp), this);
}
}
public override void Check(LabelScanDocument record, CheckerEngine <LabelScanDocument, Org.Neo4j.Consistency.report.ConsistencyReport_LabelScanConsistencyReport> engine, RecordAccess records)
{
NodeLabelRange range = record.NodeLabelRange;
foreach (long nodeId in range.Nodes())
{
long[] labels = record.NodeLabelRange.labels(nodeId);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: engine.comparativeCheck(records.node(nodeId), new org.neo4j.consistency.checking.full.NodeInUseWithCorrectLabelsCheck<>(labels, COMPLETE_ALL_TOKENS, true));
engine.ComparativeCheck(records.Node(nodeId), new NodeInUseWithCorrectLabelsCheck <RECORD, ?, REPORT>(labels, COMPLETE_ALL_TOKENS, true));
}
}
public Org.Neo4j.Consistency.store.RecordAccess MultiPassFilter(Org.Neo4j.Consistency.store.RecordAccess recordAccess, params MultiPassStore[] stores)
{
return(new FilteringRecordAccess(recordAccess, this, stores));
}
public void CheckConsistency(Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord record, CheckerEngine <Org.Neo4j.Kernel.impl.store.record.RelationshipGroupRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipGroupConsistencyReport> engine, Org.Neo4j.Consistency.store.RecordAccess records)
{
if (record.Next != Record.NO_NEXT_RELATIONSHIP.intValue())
{
engine.ComparativeCheck(records.RelationshipGroup(record.Next), this);
}
}
public virtual void CheckDiffReference(REFERENCED oldReferenced, REFERENCED newReferenced, RecordAccess records)
{
ConsistencyReporter.DispatchChangeReference(Engine(), _checker, oldReferenced, newReferenced, records);
}
public override void Check( DynamicRecord record, CheckerEngine<DynamicRecord, ConsistencyReport_DynamicLabelConsistencyReport> engine, RecordAccess records )
{
if ( record.InUse() && record.StartRecord )
{
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.Value ), _validNodeRecord );
}
}
}
