public void checkConsistency(Org.Neo4j.Kernel.impl.store.record.RelationshipRecord relationship, CheckerEngine <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipConsistencyReport> engine, Org.Neo4j.Consistency.store.RecordAccess records)
{
Org.Neo4j.Consistency.checking.cache.CacheAccess_Client cacheAccess = records.cacheAccess().client(); if (!endOfChain(relationship))
{
Org.Neo4j.Consistency.store.RecordReference <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord> referred = null; long reference = valueFrom(relationship); long nodeId = -1; if (records.shouldCheck(reference, Org.Neo4j.Consistency.checking.full.MultiPassStore.RELATIONSHIPS))
{
nodeId = NODE == NodeField.SOURCE ? relationship.getFirstNode() : relationship.getSecondNode(); if (Org.Neo4j.Kernel.impl.store.record.Record.NO_NEXT_RELATIONSHIP.@is(cacheAccess.getFromCache(nodeId, SLOT_RELATIONSHIP_ID)))
{
referred = Org.Neo4j.Consistency.store.RecordReference_SkippingReference.skipReference(); cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.noCacheSkip);
}
else
{
referred = buildFromCache(relationship, reference, nodeId, records); if (referred == Org.Neo4j.Consistency.store.RecordReference_SkippingReference.skipReference <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord>())
{
cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.skipCheck);
}
}
}
else
{
if (referenceShouldBeSkipped(relationship, reference, records))
{
referred = Org.Neo4j.Consistency.store.RecordReference_SkippingReference.skipReference();
}
}
engine.comparativeCheck(referred, this); if (referred != Org.Neo4j.Consistency.store.RecordReference_SkippingReference.skipReference <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord>())
{
cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.@checked); linkChecked(cacheAccess);
}
}
else
{
cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.@checked); linkChecked(cacheAccess);
}
}
public void checkReference(Org.Neo4j.Kernel.impl.store.record.RelationshipRecord record, Org.Neo4j.Kernel.impl.store.record.RelationshipRecord referred, CheckerEngine <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipConsistencyReport> engine, Org.Neo4j.Consistency.store.RecordAccess records)
{
NodeField field = NodeField.select(referred, node(record)); if (field == null)
{
otherNode(engine.report(), referred);
}
else
{
Org.Neo4j.Consistency.checking.cache.CacheAccess_Client cacheAccess = records.cacheAccess().client(); if (other(field, referred) != record.getId())
{
if (referred.isCreated())
{
Org.Neo4j.Consistency.store.RecordReference <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord> refRel = records.relationship(referred.getId()); referred = (Org.Neo4j.Kernel.impl.store.record.RelationshipRecord)((Org.Neo4j.Consistency.store.DirectRecordReference)refRel).record(); checkReference(record, referred, engine, records); cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.skipBackup);
}
else
{
cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.checkErrors); noBackReference(engine == null ? null : engine.report(), referred);
}
}
else
{
if (!referenceShouldBeSkipped(record, referred.getId(), records) && !referred.inUse())
{
engine.report().notUsedRelationshipReferencedInChain(referred);
}
if (referred.isCreated())
{
cacheAccess.clearCache(node(record));
}
}
}
}
protected internal override void CheckRelationship(RecordStore <RelationshipRecord> store, RelationshipRecord rel, RecordCheck <RelationshipRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipConsistencyReport> checker)
{
if (_stage != null && (_stage == CheckStage.Stage6RSForward || _stage == CheckStage.Stage7RSBackward))
{
long id = rel.Id;
Org.Neo4j.Consistency.checking.cache.CacheAccess_Client client = CacheAccess.client();
CountLinks(id, rel.FirstNextRel, client);
CountLinks(id, rel.FirstPrevRel, client);
CountLinks(id, rel.SecondNextRel, client);
CountLinks(id, rel.SecondPrevRel, client);
}
_report.forRelationship(rel, checker);
}
public virtual void CountLinks(long id1, long id2, Org.Neo4j.Consistency.checking.cache.CacheAccess_Client client)
{
Org.Neo4j.Consistency.statistics.Counts_Type type = null;
if (id2 == -1)
{
type = Org.Neo4j.Consistency.statistics.Counts_Type.NullLinks;
}
else if (id2 > id1)
{
type = Org.Neo4j.Consistency.statistics.Counts_Type.ForwardLinks;
}
else
{
type = Org.Neo4j.Consistency.statistics.Counts_Type.BackLinks;
}
client.IncAndGetCount(type);
}
public override void Process(NodeRecord nodeRecord)
{
_reporter.forNode(nodeRecord, _nodeIndexCheck);
Org.Neo4j.Consistency.checking.cache.CacheAccess_Client client = _cacheAccess.client();
using (MandatoryProperties.Check <NodeRecord, ConsistencyReport_NodeConsistencyReport> mandatoryCheck = _mandatoryProperties.apply(nodeRecord))
{
IEnumerable <PropertyRecord> properties = client.PropertiesFromCache;
// We do this null-check here because even if nodeIndexCheck should provide the properties for us,
// or an empty list at least, it may fail in one way or another and exception be caught by
// broad exception handler in reporter. The caught exception will produce an ERROR so it will not
// go by unnoticed.
if (properties != null)
{
foreach (PropertyRecord property in properties)
{
_reporter.forProperty(property, _propertyCheck);
mandatoryCheck.Receive(ChainCheck.keys(property));
}
}
}
}
internal Org.Neo4j.Consistency.store.RecordReference <Org.Neo4j.Kernel.impl.store.record.RelationshipRecord> buildFromCache(Org.Neo4j.Kernel.impl.store.record.RelationshipRecord relationship, long reference, long nodeId, Org.Neo4j.Consistency.store.RecordAccess records)
{
Org.Neo4j.Consistency.checking.cache.CacheAccess_Client cacheAccess = records.cacheAccess().client(); if (!cacheAccess.withinBounds(nodeId))
{
cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.correctSkipCheck); return(Org.Neo4j.Consistency.store.RecordReference_SkippingReference.skipReference());
}
if (reference != cacheAccess.getFromCache(nodeId, SLOT_RELATIONSHIP_ID))
{
if (referenceShouldBeSkipped(relationship, reference, records))
{
cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.correctSkipCheck); return(Org.Neo4j.Consistency.store.RecordReference_SkippingReference.skipReference());
}
cacheAccess.incAndGetCount(Org.Neo4j.Consistency.statistics.Counts_Type.missCheck); return(records.relationship(reference));
}
Org.Neo4j.Kernel.impl.store.record.RelationshipRecord rel = new Org.Neo4j.Kernel.impl.store.record.RelationshipRecord(reference); rel.setCreated(); if (cacheAccess.getFromCache(nodeId, SLOT_SOURCE_OR_TARGET) == SOURCE)
{
rel.setFirstNode(nodeId);
}
else
{
rel.setSecondNode(nodeId);
} rel = populateRelationshipFromCache(nodeId, rel, cacheAccess); return(new Org.Neo4j.Consistency.store.DirectRecordReference <>(rel, records));
}
public override void Check(NodeRecord record, CheckerEngine <NodeRecord, ConsistencyReport_NodeConsistencyReport> engine, RecordAccess records)
{
if (CountUpdateCondition.test(record))
{
if (record.InUse())
{
Org.Neo4j.Consistency.checking.cache.CacheAccess_Client client = records.CacheAccess().client();
client.PutToCacheSingle(record.Id, SLOT_IN_USE, 1);
client.PutToCacheSingle(record.Id, SLOT_LABEL_FIELD, record.LabelField);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Set<long> labels = labelsFor(nodeStore, engine, records, record.getId());
ISet <long> labels = LabelsFor(NodeStore, engine, records, record.Id);
lock ( Counts )
{
Counts.addToValue(nodeKey(WILDCARD), 1);
foreach (long label in labels)
{
Counts.addToValue(nodeKey(( int )label), 1);
}
}
}
}
Inner.check(record, engine, records);
}
internal abstract void linkChecked(Org.Neo4j.Consistency.checking.cache.CacheAccess_Client cacheAccess);
internal abstract Org.Neo4j.Kernel.impl.store.record.RelationshipRecord populateRelationshipFromCache(long nodeId, Org.Neo4j.Kernel.impl.store.record.RelationshipRecord rel, Org.Neo4j.Consistency.checking.cache.CacheAccess_Client cacheAccess);
public override void Check(RelationshipRecord record, CheckerEngine <RelationshipRecord, ConsistencyReport_RelationshipConsistencyReport> engine, RecordAccess records)
{
if (CountUpdateCondition.test(record))
{
if (record.InUse())
{
Org.Neo4j.Consistency.checking.cache.CacheAccess_Client cacheAccess = records.CacheAccess().client();
ISet <long> firstNodeLabels;
ISet <long> secondNodeLabels;
long firstLabelsField = cacheAccess.GetFromCache(record.FirstNode, SLOT_LABEL_FIELD);
if (NodeLabelsField.fieldPointsToDynamicRecordOfLabels(firstLabelsField))
{
firstNodeLabels = LabelsFor(NodeStore, engine, records, record.FirstNode);
}
else
{
firstNodeLabels = NodeLabelReader.GetListOfLabels(firstLabelsField);
}
long secondLabelsField = cacheAccess.GetFromCache(record.SecondNode, SLOT_LABEL_FIELD);
if (NodeLabelsField.fieldPointsToDynamicRecordOfLabels(secondLabelsField))
{
secondNodeLabels = LabelsFor(NodeStore, engine, records, record.SecondNode);
}
else
{
secondNodeLabels = NodeLabelReader.GetListOfLabels(secondLabelsField);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int type = record.getType();
int type = record.Type;
lock ( Counts )
{
Counts.addToValue(relationshipKey(WILDCARD, WILDCARD, WILDCARD), 1);
Counts.addToValue(relationshipKey(WILDCARD, type, WILDCARD), 1);
if (firstNodeLabels != null)
{
foreach (long firstLabel in firstNodeLabels)
{
Counts.addToValue(relationshipKey(( int )firstLabel, WILDCARD, WILDCARD), 1);
Counts.addToValue(relationshipKey(( int )firstLabel, type, WILDCARD), 1);
}
}
if (secondNodeLabels != null)
{
foreach (long secondLabel in secondNodeLabels)
{
Counts.addToValue(relationshipKey(WILDCARD, WILDCARD, ( int )secondLabel), 1);
Counts.addToValue(relationshipKey(WILDCARD, type, ( int )secondLabel), 1);
}
}
if (COMPUTE_DOUBLE_SIDED_RELATIONSHIP_COUNTS)
{
foreach (long firstLabel in firstNodeLabels)
{
foreach (long secondLabel in secondNodeLabels)
{
Counts.addToValue(relationshipKey(( int )firstLabel, WILDCARD, ( int )secondLabel), 1);
Counts.addToValue(relationshipKey(( int )firstLabel, type, ( int )secondLabel), 1);
}
}
}
}
}
}
Inner.check(record, engine, records);
}
