public override void CheckIndexRule(StoreIndexDescriptor rule, DynamicRecord record, RecordAccess records, CheckerEngine <DynamicRecord, Org.Neo4j.Consistency.report.ConsistencyReport_SchemaConsistencyReport> engine) { if (rule.CanSupportUniqueConstraint()) { DynamicRecord obligation = outerInstance.indexObligations[rule.Id]; if (obligation == null) // no pointer to here { if (rule.OwningConstraint != null) // we only expect a pointer if we have an owner { engine.Report().missingObligation(Org.Neo4j.Storageengine.Api.schema.SchemaRule_Kind.UniquenessConstraint); } } else { // if someone points to here, it must be our owner if (obligation.Id != rule.OwningConstraint.Value) { engine.Report().constraintIndexRuleNotReferencingBack(obligation); } } } if (outerInstance.indexAccessors.NotOnlineRules().Contains(rule)) { engine.Report().schemaRuleNotOnline(rule); } }
public override void CheckIndexRule(StoreIndexDescriptor rule, DynamicRecord record, RecordAccess records, CheckerEngine <DynamicRecord, Org.Neo4j.Consistency.report.ConsistencyReport_SchemaConsistencyReport> engine) { outerInstance.checkSchema(rule, record, records, engine); if (rule.CanSupportUniqueConstraint() && rule.OwningConstraint != null) { DynamicRecord previousObligation = outerInstance.constraintObligations[rule.OwningConstraint] = record.Clone(); if (previousObligation != null) { engine.Report().duplicateObligation(previousObligation); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public boolean visitSchemaRuleCommand(Command.SchemaRuleCommand command) throws java.io.IOException public override bool VisitSchemaRuleCommand(Command.SchemaRuleCommand command) { SchemaRule schemaRule = command.SchemaRule; if (command.SchemaRule is StoreIndexDescriptor) { StoreIndexDescriptor indexRule = ( StoreIndexDescriptor )schemaRule; // Why apply index updates here? Here's the thing... this is a batch applier, which means that // index updates are gathered throughout the batch and applied in the end of the batch. // Assume there are some transactions creating or modifying nodes that may not be covered // by an existing index, but a later transaction in the same batch creates such an index. // In that scenario the index would be created, populated and then fed the [this time duplicate] // update for the node created before the index. The most straight forward solution is to // apply pending index updates up to this point in this batch before index schema changes occur. outerInstance.applyPendingLabelAndIndexUpdates(); switch (command.Mode) { case UPDATE: // Shouldn't we be more clear about that we are waiting for an index to come online here? // right now we just assume that an update to index records means wait for it to be online. if (indexRule.CanSupportUniqueConstraint()) { // Register activations into the IndexActivator instead of IndexingService to avoid deadlock // that could insue for applying batches of transactions where a previous transaction in the same // batch acquires a low-level commit lock that prevents the very same index population to complete. outerInstance.indexActivator.ActivateIndex(schemaRule.Id); } break; case CREATE: // Add to list so that all these indexes will be created in one call later CreatedIndexes = CreatedIndexes == null ? new List <StoreIndexDescriptor>() : CreatedIndexes; CreatedIndexes.Add(indexRule); break; case DELETE: outerInstance.indexingService.DropIndex(indexRule); outerInstance.indexActivator.IndexDropped(schemaRule.Id); break; default: throw new System.InvalidOperationException(command.Mode.name()); } } // Keep IndexingService updated on constraint changes else if (schemaRule is ConstraintRule) { ConstraintRule constraintRule = ( ConstraintRule )schemaRule; switch (command.Mode) { case CREATE: case UPDATE: outerInstance.indexingService.PutConstraint(constraintRule); break; case DELETE: outerInstance.indexingService.RemoveConstraint(constraintRule.Id); break; default: throw new System.InvalidOperationException(command.Mode.name()); } } return(false); }