private void setCorrectNextRel(NodeRecord node, RelationshipRecord rel, long nextRel) { if (node.getId() == rel.getFirstNode()) { rel.setFirstNextRel(nextRel); } if (node.getId() == rel.getSecondNode()) { rel.setSecondNextRel(nextRel); } }
@Override public Collection<DynamicRecord> put(long[] labelIds, NodeStore nodeStore) { long existingLabelsField = node.getLabelField(); long existingLabelsBits = parseLabelsBody(existingLabelsField); Collection<DynamicRecord> changedDynamicRecords = node.getDynamicLabelRecords(); if (labelField != 0) { // There are existing dynamic label records, get them nodeStore.ensureHeavy(node, existingLabelsBits); changedDynamicRecords = node.getDynamicLabelRecords(); setNotInUse(changedDynamicRecords); } if (!new InlineNodeLabels(labelField, node) .tryInlineInNodeRecord(labelIds, changedDynamicRecords)) { Set<DynamicRecord> allRecords = new HashSet<>(changedDynamicRecords); Collection<DynamicRecord> allocatedRecords = nodeStore.allocateRecordsForDynamicLabels( node.getId(), labelIds, changedDynamicRecords.iterator()); allRecords.addAll(allocatedRecords); node.setLabelField(dynamicPointer(allocatedRecords), allocatedRecords); changedDynamicRecords = allRecords; } return changedDynamicRecords; }
@Override public Collection<DynamicRecord> remove(long labelId, NodeStore nodeStore) { nodeStore.ensureHeavy(node, parseLabelsBody(labelField)); Collection<DynamicRecord> existingRecords = node.getDynamicLabelRecords(); long[] existingLabelIds = nodeStore.getDynamicLabelsArray(existingRecords); long[] newLabelIds = filter(existingLabelIds, labelId); if (new InlineNodeLabels(labelField, node) .tryInlineInNodeRecord(newLabelIds, existingRecords)) { setNotInUse(existingRecords); } else { Collection<DynamicRecord> newRecords = nodeStore.allocateRecordsForDynamicLabels( node.getId(), newLabelIds, existingRecords.iterator()); node.setLabelField(dynamicPointer(newRecords), existingRecords); if (!newRecords.equals( existingRecords)) { // One less dynamic record, mark that one as not in use for (DynamicRecord record : existingRecords) { if (!newRecords.contains(record)) { record.setInUse(false); record.setLength(0); // so that it will not be made heavy again... } } } } return existingRecords; }
private void connect(NodeRecord node, RelationshipRecord rel) { if (node.getNextRel() != Record.NO_NEXT_RELATIONSHIP.intValue()) { RelationshipRecord nextRel = getRelationshipStore().getRecord(node.getNextRel()); boolean changed = false; if (nextRel.getFirstNode() == node.getId()) { nextRel.setFirstPrevRel(rel.getId()); changed = true; } if (nextRel.getSecondNode() == node.getId()) { nextRel.setSecondPrevRel(rel.getId()); changed = true; } if (!changed) { throw new InvalidRecordException(node + " dont match " + nextRel); } getRelationshipStore().updateRecord(nextRel); } }
@Test public void shouldNotReportMissingPropertyForDeletedNodeWithProperty() { // given PropertyRecord oldProperty = add(inUse(new PropertyRecord(10))); NodeRecord oldNode = add(inUse(new NodeRecord(20, false, 0, 0))); oldProperty.setNodeId(oldNode.getId()); oldNode.setNextProp(oldProperty.getId()); PropertyRecord newProperty = add(notInUse(new PropertyRecord(10))); NodeRecord newNode = add(notInUse(new NodeRecord(20, false, 0, 0))); newProperty.setNodeId(newNode.getId()); newNode.setNextProp(newProperty.getId()); // when ConsistencyReport.PropertyConsistencyReport report = checkChange(oldProperty, newProperty); // then verifyNoMoreInteractions(report); }
private void connectRelationship( NodeRecord firstNode, NodeRecord secondNode, RelationshipRecord rel, RecordAccess<Long, RelationshipRecord, Void> relRecords, RecordAccess<Long, RelationshipGroupRecord, Integer> relGroupRecords) { // Assertion interpreted: if node is a normal node and we're trying to create a // relationship that we already have as first rel for that node --> error assert firstNode.getNextRel() != rel.getId() || firstNode.isDense(); assert secondNode.getNextRel() != rel.getId() || secondNode.isDense(); if (!firstNode.isDense()) { rel.setFirstNextRel(firstNode.getNextRel()); } if (!secondNode.isDense()) { rel.setSecondNextRel(secondNode.getNextRel()); } if (!firstNode.isDense()) { connect(firstNode, rel, relRecords); } else { connectRelationshipToDenseNode(firstNode, rel, relRecords, relGroupRecords); } if (!secondNode.isDense()) { if (firstNode.getId() != secondNode.getId()) { connect(secondNode, rel, relRecords); } else { rel.setFirstInFirstChain(true); rel.setSecondPrevRel(rel.getFirstPrevRel()); } } else if (firstNode.getId() != secondNode.getId()) { connectRelationshipToDenseNode(secondNode, rel, relRecords, relGroupRecords); } if (!firstNode.isDense()) { firstNode.setNextRel(rel.getId()); } if (!secondNode.isDense()) { secondNode.setNextRel(rel.getId()); } }
private void migrateNodes(NodeStore nodeStore, PropertyWriter propertyWriter) throws IOException { Iterable<NodeRecord> records = legacyStore.getNodeStoreReader().readNodeStore(); // estimate total number of nodes using file size then calc number of dots or percentage // complete for (NodeRecord nodeRecord : records) { reportProgress(nodeRecord.getId()); nodeStore.setHighId(nodeRecord.getId() + 1); if (nodeRecord.inUse()) { long startOfPropertyChain = nodeRecord.getNextProp(); if (startOfPropertyChain != Record.NO_NEXT_RELATIONSHIP.intValue()) { long propertyRecordId = migrateProperties(startOfPropertyChain, propertyWriter); nodeRecord.setNextProp(propertyRecordId); } nodeStore.updateRecord(nodeRecord); } else { nodeStore.freeId(nodeRecord.getId()); } } legacyStore.getNodeStoreReader().close(); }
@Override public Collection<DynamicRecord> add(long labelId, NodeStore nodeStore) { nodeStore.ensureHeavy(node, parseLabelsBody(labelField)); Collection<DynamicRecord> existingRecords = node.getDynamicLabelRecords(); long[] existingLabelIds = nodeStore.getDynamicLabelsArray(existingRecords); long[] newLabelIds = LabelIdArray.concatAndSort(existingLabelIds, labelId); Collection<DynamicRecord> changedDynamicRecords = nodeStore.allocateRecordsForDynamicLabels( node.getId(), newLabelIds, existingRecords.iterator()); node.setLabelField(dynamicPointer(changedDynamicRecords), changedDynamicRecords); return changedDynamicRecords; }
private void connectRelationshipToDenseNode( NodeRecord node, RelationshipRecord rel, RecordAccess<Long, RelationshipRecord, Void> relRecords, RecordAccess<Long, RelationshipGroupRecord, Integer> relGroupRecords) { RelationshipGroupRecord group = relGroupGetter .getOrCreateRelationshipGroup(node, rel.getType(), relGroupRecords) .forChangingData(); RelIdArray.DirectionWrapper dir = DirectionIdentifier.wrapDirection(rel, node); long nextRel = dir.getNextRel(group); setCorrectNextRel(node, rel, nextRel); connect(node.getId(), nextRel, rel, relRecords); dir.setNextRel(group, rel.getId()); }
private void convertNodeToDenseIfNecessary( NodeRecord node, RecordAccess<Long, RelationshipRecord, Void> relRecords, RecordAccess<Long, RelationshipGroupRecord, Integer> relGroupRecords) { if (node.isDense()) { return; } long relId = node.getNextRel(); if (relId != Record.NO_NEXT_RELATIONSHIP.intValue()) { RecordProxy<Long, RelationshipRecord, Void> relChange = relRecords.getOrLoad(relId, null); RelationshipRecord rel = relChange.forReadingLinkage(); if (RelationshipCounter.relCount(node.getId(), rel) >= neoStore.getDenseNodeThreshold()) { convertNodeToDenseNode(node, relChange.forChangingLinkage(), relRecords, relGroupRecords); } } }
private void convertNodeToDenseNode( NodeRecord node, RelationshipRecord firstRel, RecordAccess<Long, RelationshipRecord, Void> relRecords, RecordAccess<Long, RelationshipGroupRecord, Integer> relGroupRecords) { firstRel = relRecords.getOrLoad(firstRel.getId(), null).forChangingLinkage(); node.setDense(true); node.setNextRel(Record.NO_NEXT_RELATIONSHIP.intValue()); long relId = firstRel.getId(); RelationshipRecord relRecord = firstRel; while (relId != Record.NO_NEXT_RELATIONSHIP.intValue()) { locker.getWriteLock(relId); relId = relChain(relRecord, node.getId()).get(relRecord); connectRelationshipToDenseNode(node, relRecord, relRecords, relGroupRecords); if (relId == Record.NO_NEXT_RELATIONSHIP.intValue()) { break; } relRecord = relRecords.getOrLoad(relId, null).forChangingLinkage(); } if (upgradedDenseNodes == null) { upgradedDenseNodes = new ArrayList<>(); } upgradedDenseNodes.add(node); }
private void connect( NodeRecord node, RelationshipRecord rel, RecordAccess<Long, RelationshipRecord, Void> relRecords) { connect(node.getId(), node.getNextRel(), rel, relRecords); }
public void updateFirstRelationships() { for (RecordProxy<Long, NodeRecord, Void> change : recordChangeSet.getNodeRecords().changes()) { NodeRecord record = change.forReadingLinkage(); txState.setFirstIds(record.getId(), record.getNextRel(), record.getNextProp()); } }
public NodeCommand init(NodeRecord before, NodeRecord after) { setup(after.getId(), Mode.fromRecordState(after)); this.before = before; this.after = after; return this; }