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 Check(DynamicRecord record, CheckerEngine <DynamicRecord, Org.Neo4j.Consistency.report.ConsistencyReport_SchemaConsistencyReport> engine, RecordAccess records)
{
if (record.InUse() && record.StartRecord)
{
// parse schema rule
SchemaRule rule;
try
{
rule = RuleAccess.loadSingleSchemaRule(record.Id);
}
catch (MalformedSchemaRuleException)
{
engine.Report().malformedSchemaRule();
return;
}
if (rule is StoreIndexDescriptor)
{
_strategy.checkIndexRule(( StoreIndexDescriptor )rule, record, records, engine);
}
else if (rule is ConstraintRule)
{
_strategy.checkConstraintRule(( ConstraintRule )rule, record, records, engine);
}
else
{
engine.Report().unsupportedSchemaRuleKind(null);
}
}
}
public override void CheckReference(RECORD record, NodeRecord nodeRecord, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
if (nodeRecord.InUse())
{
NodeLabels nodeLabels = NodeLabelsField.parseLabelsField(nodeRecord);
if (nodeLabels is DynamicNodeLabels)
{
DynamicNodeLabels dynamicNodeLabels = ( DynamicNodeLabels )nodeLabels;
long firstRecordId = dynamicNodeLabels.FirstDynamicRecordId;
RecordReference <DynamicRecord> firstRecordReference = records.NodeLabels(firstRecordId);
ExpectedNodeLabelsChecker expectedNodeLabelsChecker = new ExpectedNodeLabelsChecker(this, nodeRecord);
LabelChainWalker <RECORD, REPORT> checker = new LabelChainWalker <RECORD, REPORT>(expectedNodeLabelsChecker);
engine.ComparativeCheck(firstRecordReference, checker);
nodeRecord.DynamicLabelRecords; // I think this is empty in production
}
else
{
long[] storeLabels = nodeLabels.Get(null);
REPORT report = engine.Report();
ValidateLabelIds(nodeRecord, storeLabels, report);
}
}
else if (_indexLabels.Length != 0)
{
engine.Report().nodeNotInUse(nodeRecord);
}
}
private void CheckProperty(NodeRecord record, CheckerEngine <NodeRecord, Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport> engine, ICollection <PropertyRecord> props)
{
if (!Record.NO_NEXT_PROPERTY.@is(record.NextProp))
{
PropertyRecord firstProp = props.GetEnumerator().next();
if (!Record.NO_PREVIOUS_PROPERTY.@is(firstProp.PrevProp))
{
engine.Report().propertyNotFirstInChain(firstProp);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableIntSet keys = new org.eclipse.collections.impl.set.mutable.primitive.IntHashSet();
MutableIntSet keys = new IntHashSet();
foreach (PropertyRecord property in props)
{
if (!property.InUse())
{
engine.Report().propertyNotInUse(property);
}
else
{
foreach (int key in ChainCheck.keys(property))
{
if (!keys.add(key))
{
engine.Report().propertyKeyNotUniqueInChain();
}
}
}
}
}
}
public override void Check(RelationshipRecord record, CheckerEngine <RelationshipRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipConsistencyReport> engine, RecordAccess records)
{
try
{
IntObjectMap <PropertyBlock> propertyMap = null;
foreach (StoreIndexDescriptor index in _relationshipIndexes)
{
SchemaDescriptor schema = index.Schema();
if (ArrayUtils.contains(Schema.EntityTokenIds, record.Type))
{
if (propertyMap == null)
{
ICollection <PropertyRecord> propertyRecs = _propertyReader.getPropertyRecordChain(record.NextProp);
propertyMap = properties(_propertyReader.propertyBlocks(propertyRecs));
}
if (entityIntersectsSchema(propertyMap, schema))
{
Value[] values = getPropertyValues(_propertyReader, propertyMap, Schema.PropertyIds);
using (IndexReader reader = _indexes.accessorFor(index).newReader())
{
long entityId = record.Id;
long count = reader.CountIndexedNodes(entityId, Schema.PropertyIds, values);
ReportIncorrectIndexCount(values, engine, index, count);
}
}
}
}
}
catch (PropertyReader.CircularPropertyRecordChainException)
{
// The property chain contains a circular reference and is therefore not sane.
// Skip it, since this inconsistency has been reported by PropertyChain checker already.
}
}
public void checkConsistency(NodeRecord node, CheckerEngine <NodeRecord, ConsistencyReport_NodeConsistencyReport> engine, RecordAccess records)
{
if (!Record.NO_NEXT_RELATIONSHIP.@is(node.NextRel))
{
engine.comparativeCheck(records.relationshipGroup(node.NextRel), this);
}
}
internal static void DispatchChangeReference(CheckerEngine engine, ComparativeRecordChecker checker, AbstractBaseRecord oldReferenced, AbstractBaseRecord newReferenced, RecordAccess records)
{
ReportInvocationHandler handler = ( ReportInvocationHandler )engine;
handler.checkDiffReference(engine, checker, oldReferenced, newReferenced, records);
handler.updateSummary();
}
private void CheckForDuplicates(SchemaRule rule, DynamicRecord record, CheckerEngine <DynamicRecord, Org.Neo4j.Consistency.report.ConsistencyReport_SchemaConsistencyReport> engine)
{
DynamicRecord previousContentRecord = _verifiedRulesWithRecords[rule] = record.Clone();
if (previousContentRecord != null)
{
engine.Report().duplicateRuleContent(previousContentRecord);
}
}
private void ReportIncorrectIndexCount(Value[] propertyValues, CheckerEngine <NodeRecord, Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport> engine, StoreIndexDescriptor indexRule, long count)
{
if (count == 0)
{
engine.Report().notIndexed(indexRule, Values.asObjects(propertyValues));
}
else if (count != 1)
{
engine.Report().indexedMultipleTimes(indexRule, Values.asObjects(propertyValues), count);
}
}
public override void check(CountsEntry record, CheckerEngine <CountsEntry, Org.Neo4j.Consistency.report.ConsistencyReport_CountsConsistencyReport> engine, RecordAccess records)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long expectedCount = relationshipCounts.get(record.getCountsKey());
long expectedCount = outerInstance.relationshipCounts.get(record.CountsKey);
if (expectedCount != record.Count)
{
engine.Report().inconsistentRelationshipCount(expectedCount);
}
}
public virtual void Skip()
{
lock (this)
{
if (_engine != null)
{
ConsistencyReporter.DispatchSkip(_engine);
_engine = null;
}
}
}
public override void check(CountsEntry record, CheckerEngine <CountsEntry, Org.Neo4j.Consistency.report.ConsistencyReport_CountsConsistencyReport> engine, RecordAccess records)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int expectedCount = nodeCounts.size();
int expectedCount = outerInstance.nodeCounts.size();
if (record.Count != expectedCount)
{
engine.Report().inconsistentNumberOfNodeKeys(expectedCount);
}
}
public override void Check(RECORD record, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
if (!record.inUse())
{
return;
}
if (!Record.NO_NEXT_BLOCK.@is(record.NameId))
{
engine.ComparativeCheck(Name(records, record.NameId), this);
}
}
public override void Check(RelationshipGroupRecord record, CheckerEngine <RelationshipGroupRecord, ConsistencyReport_RelationshipGroupConsistencyReport> engine, RecordAccess records)
{
if (!record.InUse())
{
return;
}
foreach (RecordField <RelationshipGroupRecord, ConsistencyReport_RelationshipGroupConsistencyReport> field in _fields)
{
field.CheckConsistency(record, engine, records);
}
}
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);
}
}
private void ReportIncorrectIndexCount(Value[] values, CheckerEngine <RelationshipRecord, Org.Neo4j.Consistency.report.ConsistencyReport_RelationshipConsistencyReport> engine, StoreIndexDescriptor index, long count)
{
if (count == 0)
{
engine.Report().notIndexed(index, Values.asObjects(values));
}
else if (count != 1)
{
engine.Report().indexedMultipleTimes(index, Values.asObjects(values), count);
}
}
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 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 CheckReference(RECORD record, DynamicRecord name, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
if (!name.InUse())
{
NameNotInUse(engine.Report(), name);
}
else
{
if (name.Length <= 0)
{
EmptyName(engine.Report(), name);
}
}
}
public override void Check(PropertyRecord record, CheckerEngine <PropertyRecord, Org.Neo4j.Consistency.report.ConsistencyReport_PropertyConsistencyReport> engine, RecordAccess records)
{
if (!record.InUse())
{
return;
}
foreach (PropertyField field in PropertyField.values())
{
field.checkConsistency(record, engine, records);
}
foreach (PropertyBlock block in record)
{
CheckDataBlock(block, engine, records);
}
}
public override 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.PrevProp))
{
engine.Report().propertyNotFirstInChain(property);
}
(new ChainCheck <RECORD, REPORT>()).CheckReference(record, property, engine, records);
}
}
public override void Check(NodeRecord record, CheckerEngine <NodeRecord, Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport> engine, RecordAccess records)
{
try
{
ICollection <PropertyRecord> properties = _propertyReader.getPropertyRecordChain(record.NextProp);
_cacheAccess.client().putPropertiesToCache(properties);
if (_indexes != null)
{
MatchIndexesToNode(record, engine, records, properties);
}
CheckProperty(record, engine, properties);
}
catch (PropertyReader.CircularPropertyRecordChainException e)
{
engine.Report().propertyChainContainsCircularReference(e.PropertyRecordClosingTheCircle());
}
}
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 );
}
}
}
private CheckerEngine Engine()
{
lock (this)
{
if (_engine == null)
{
throw new System.InvalidOperationException("Reference has already been checked.");
}
try
{
return(_engine);
}
finally
{
_engine = null;
}
}
}
public override void CheckConsistency(RECORD record, CheckerEngine <RECORD, REPORT> engine, RecordAccess records)
{
if (!Record.NO_NEXT_PROPERTY.@is(record.NextProp))
{
// Check the whole chain here instead of scattered during multiple checks.
// This type of check obviously favors chains with good locality, performance-wise.
IEnumerator <PropertyRecord> props = records.RawPropertyChain(record.NextProp);
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
PropertyRecord firstProp = props.next();
if (!Record.NO_PREVIOUS_PROPERTY.@is(firstProp.PrevProp))
{
engine.Report().propertyNotFirstInChain(firstProp);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableIntSet keys = new org.eclipse.collections.impl.set.mutable.primitive.IntHashSet();
MutableIntSet keys = new IntHashSet();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableLongSet propertyRecordIds = new org.eclipse.collections.impl.set.mutable.primitive.LongHashSet(8);
MutableLongSet propertyRecordIds = new LongHashSet(8);
propertyRecordIds.add(firstProp.Id);
using (MandatoryProperties.Check <RECORD, REPORT> mandatory = _mandatoryProperties.apply(record))
{
CheckChainItem(firstProp, engine, keys, mandatory);
// Check the whole chain here. We also take the opportunity to check mandatory property constraints.
PropertyRecord prop = firstProp;
while (props.MoveNext())
{
PropertyRecord nextProp = props.Current;
if (!propertyRecordIds.add(nextProp.Id))
{
engine.Report().propertyChainContainsCircularReference(prop);
break;
}
CheckChainItem(nextProp, engine, keys, mandatory);
prop = nextProp;
}
}
}
}
public static void CheckDataBlock(PropertyBlock block, CheckerEngine <PropertyRecord, Org.Neo4j.Consistency.report.ConsistencyReport_PropertyConsistencyReport> engine, RecordAccess records)
{
if (block.KeyIndexId < 0)
{
engine.Report().invalidPropertyKey(block);
}
else
{
engine.ComparativeCheck(records.PropertyKey(block.KeyIndexId), PropertyKey(block));
}
PropertyType type = block.ForceGetType();
if (type == null)
{
engine.Report().invalidPropertyType(block);
}
else
{
switch (type.innerEnumValue)
{
case PropertyType.InnerEnum.STRING:
engine.ComparativeCheck(records.String(block.SingleValueLong), DynamicReference.String(block));
break;
case PropertyType.InnerEnum.ARRAY:
engine.ComparativeCheck(records.Array(block.SingleValueLong), DynamicReference.Array(block));
break;
default:
try
{
type.value(block, null);
}
catch (Exception)
{
engine.Report().invalidPropertyValue(block);
}
break;
}
}
}
private void CheckChainItem(PropertyRecord property, CheckerEngine <RECORD, REPORT> engine, MutableIntSet keys, MandatoryProperties.Check <RECORD, REPORT> mandatory)
{
if (!property.InUse())
{
engine.Report().propertyNotInUse(property);
}
else
{
int[] keysInRecord = ChainCheck.Keys(property);
if (mandatory != null)
{
mandatory.Receive(keysInRecord);
}
foreach (int key in keysInRecord)
{
if (!keys.add(key))
{
engine.Report().propertyKeyNotUniqueInChain();
}
}
}
}
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 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);
}
/// <summary>
/// Matches indexes to a node.
/// </summary>
private void MatchIndexesToNode(NodeRecord record, CheckerEngine <NodeRecord, Org.Neo4j.Consistency.report.ConsistencyReport_NodeConsistencyReport> engine, RecordAccess records, ICollection <PropertyRecord> propertyRecs)
{
long[] labels = NodeLabelReader.GetListOfLabels(record, records, engine).Select(long?.longValue).ToArray();
IntObjectMap <PropertyBlock> nodePropertyMap = null;
foreach (StoreIndexDescriptor indexRule in _indexes.onlineRules())
{
SchemaDescriptor schema = indexRule.Schema();
if (Schema.entityType() == EntityType.NODE && Schema.isAffected(labels))
{
if (nodePropertyMap == null)
{
nodePropertyMap = Properties(_propertyReader.propertyBlocks(propertyRecs));
}
if (EntityIntersectsSchema(nodePropertyMap, schema))
{
Value[] values = GetPropertyValues(_propertyReader, nodePropertyMap, Schema.PropertyIds);
using (IndexReader reader = _indexes.accessorFor(indexRule).newReader())
{
long nodeId = record.Id;
if (indexRule.CanSupportUniqueConstraint())
{
VerifyNodeCorrectlyIndexedUniquely(nodeId, values, engine, indexRule, reader);
}
else
{
long count = reader.CountIndexedNodes(nodeId, Schema.PropertyIds, values);
ReportIncorrectIndexCount(values, engine, indexRule, count);
}
}
}
}
}
}
