public override void Feed(EntityCommandGrouper <Command.NodeCommand> .Cursor nodeCommands, EntityCommandGrouper <Command.RelationshipCommand> .Cursor relationshipCommands) { while (nodeCommands.nextEntity()) { GatherUpdatesFor(nodeCommands.currentEntityId(), nodeCommands.currentEntityCommand(), nodeCommands); } while (relationshipCommands.nextEntity()) { GatherUpdatesFor(relationshipCommands.currentEntityId(), relationshipCommands.currentEntityCommand(), relationshipCommands); } }
private void GatherUpdatesFor(long nodeId, Command.NodeCommand nodeCommand, EntityCommandGrouper <Command.NodeCommand> .Cursor propertyCommands) { EntityUpdates.Builder nodePropertyUpdate = GatherUpdatesFromCommandsForNode(nodeId, nodeCommand, propertyCommands); EntityUpdates entityUpdates = nodePropertyUpdate.Build(); // we need to materialize the IndexEntryUpdates here, because when we // consume (later in separate thread) the store might have changed. foreach (IndexEntryUpdate <SchemaDescriptor> update in _updateService.convertToIndexUpdates(entityUpdates, EntityType.NODE)) { _updates.Add(update); } }
private EntityCommandGrouper <ENTITY> .Cursor Group <ENTITY>(ENTITY entityCommand, Type cls, params Command.PropertyCommand[] propertyCommands) where ENTITY : Org.Neo4j.Kernel.impl.transaction.command.Command { cls = typeof(ENTITY); EntityCommandGrouper <ENTITY> grouper = new EntityCommandGrouper <ENTITY>(cls, 8); if (entityCommand != null) { grouper.Add(entityCommand); } foreach (Command.PropertyCommand propertyCommand in propertyCommands) { grouper.Add(propertyCommand); } return(grouper.SortAndAccessGroups()); }
public override void Feed(EntityCommandGrouper <Command.NodeCommand> .Cursor nodeCommands, EntityCommandGrouper <Command.RelationshipCommand> .Cursor relationshipCommands) { throw new System.NotSupportedException(); }
private EntityUpdates.Builder GatherUpdatesFromCommandsForRelationship(long relationshipId, Command.RelationshipCommand relationshipCommand, EntityCommandGrouper <Command.RelationshipCommand> .Cursor propertyCommands) { long reltypeBefore; long reltypeAfter; if (relationshipCommand != null) { reltypeBefore = relationshipCommand.Before.Type; reltypeAfter = relationshipCommand.After.Type; } else { RelationshipRecord relationshipRecord = LoadRelationship(relationshipId); reltypeBefore = reltypeAfter = relationshipRecord.Type; } bool complete = ProvidesCompleteListOfProperties(relationshipCommand); EntityUpdates.Builder relationshipPropertyUpdates = EntityUpdates.forEntity(relationshipId, complete).withTokens(reltypeBefore).withTokensAfter(reltypeAfter); _converter.convertPropertyRecord(propertyCommands, relationshipPropertyUpdates); return(relationshipPropertyUpdates); }
private EntityUpdates.Builder GatherUpdatesFromCommandsForNode(long nodeId, Command.NodeCommand nodeChanges, EntityCommandGrouper <Command.NodeCommand> .Cursor propertyCommandsForNode) { long[] nodeLabelsBefore; long[] nodeLabelsAfter; if (nodeChanges != null) { nodeLabelsBefore = parseLabelsField(nodeChanges.Before).get(_nodeStore); nodeLabelsAfter = parseLabelsField(nodeChanges.After).get(_nodeStore); } else { /* If the node doesn't exist here then we've most likely encountered this scenario: * - TX1: Node N exists and has property record P * - rotate log * - TX2: P gets changed * - TX3: N gets deleted (also P, but that's irrelevant for this scenario) * - N is persisted to disk for some reason * - crash * - recover * - TX2: P has changed and updates to indexes are gathered. As part of that it tries to read * the labels of N (which does not exist a.t.m.). * * We can actually (if we disregard any potential inconsistencies) just assume that * if this happens and we're in recovery mode that the node in question will be deleted * in an upcoming transaction, so just skip this update. */ NodeRecord nodeRecord = LoadNode(nodeId); nodeLabelsBefore = nodeLabelsAfter = parseLabelsField(nodeRecord).get(_nodeStore); } // First get possible Label changes bool complete = ProvidesCompleteListOfProperties(nodeChanges); EntityUpdates.Builder nodePropertyUpdates = EntityUpdates.forEntity(nodeId, complete).withTokens(nodeLabelsBefore).withTokensAfter(nodeLabelsAfter); // Then look for property changes _converter.convertPropertyRecord(propertyCommandsForNode, nodePropertyUpdates); return(nodePropertyUpdates); }
private void GatherUpdatesFor(long relationshipId, Command.RelationshipCommand relationshipCommand, EntityCommandGrouper <Command.RelationshipCommand> .Cursor propertyCommands) { EntityUpdates.Builder relationshipPropertyUpdate = GatherUpdatesFromCommandsForRelationship(relationshipId, relationshipCommand, propertyCommands); EntityUpdates entityUpdates = relationshipPropertyUpdate.Build(); // we need to materialize the IndexEntryUpdates here, because when we // consume (later in separate thread) the store might have changed. foreach (IndexEntryUpdate <SchemaDescriptor> update in _updateService.convertToIndexUpdates(entityUpdates, EntityType.RELATIONSHIP)) { _updates.Add(update); } }