private int getOrCreateRelationshipTypeToken(RelationshipType type) { int typeId = relationshipTypeTokens.idOf(type.name()); if (typeId == -1) { typeId = createNewRelationshipType(type.name()); } return typeId; }
private boolean removePrimitiveProperty(PrimitiveRecord primitive, String property) { PropertyRecord current = null; PropertyBlock target; long nextProp = primitive.getNextProp(); int propIndex = propertyKeyTokens.idOf(property); if (nextProp == Record.NO_NEXT_PROPERTY.intValue() || propIndex == -1) { // No properties or no one has that property, nothing changed return false; } while (nextProp != Record.NO_NEXT_PROPERTY.intValue()) { current = getPropertyStore().getRecord(nextProp); if ((target = current.removePropertyBlock(propIndex)) != null) { getPropertyStore().ensureHeavy(target); for (DynamicRecord dynRec : target.getValueRecords()) { dynRec.setInUse(false); current.addDeletedRecord(dynRec); } break; } nextProp = current.getNextProp(); } assert current != null : "the if statement above prevents it"; if (current.size() > 0) { getPropertyStore().updateRecord(current); return false; } else { current.setInUse(false); return unlinkPropertyRecord(current, primitive); } }
@Override public Iterable<BatchRelationship> getRelationships(long nodeId) { NodeRecord nodeRecord = getNodeRecord(nodeId); long nextRel = nodeRecord.getNextRel(); List<BatchRelationship> rels = new ArrayList<>(); while (nextRel != Record.NO_NEXT_RELATIONSHIP.intValue()) { RelationshipRecord relRecord = getRelationshipRecord(nextRel); RelationshipType type = new RelationshipTypeImpl(relationshipTypeTokens.nameOf(relRecord.getType())); rels.add( new BatchRelationship( relRecord.getId(), relRecord.getFirstNode(), relRecord.getSecondNode(), type)); long firstNode = relRecord.getFirstNode(); long secondNode = relRecord.getSecondNode(); if (firstNode == nodeId) { nextRel = relRecord.getFirstNextRel(); } else if (secondNode == nodeId) { nextRel = relRecord.getSecondNextRel(); } else { throw new InvalidRecordException( "Node[" + nodeId + "] not part of firstNode[" + firstNode + "] or secondNode[" + secondNode + "]"); } } return rels; }
private boolean primitiveHasProperty(PrimitiveRecord record, String propertyName) { int propertyKeyId = propertyKeyTokens.idOf(propertyName); return propertyKeyId != -1 && propertyTraverser.findPropertyRecordContaining( record, propertyKeyId, recordAccess.getPropertyRecords(), false) != Record.NO_NEXT_PROPERTY.intValue(); }
@Override public BatchRelationship getRelationshipById(long relId) { RelationshipRecord record = getRelationshipRecord(relId).forReadingData(); RelationshipType type = new RelationshipTypeImpl(relationshipTypeTokens.nameOf(record.getType())); return new BatchRelationship( record.getId(), record.getFirstNode(), record.getSecondNode(), type); }
private int createNewPropertyKeyId(String stringKey) { PropertyKeyTokenStore idxStore = getPropertyKeyTokenStore(); int keyId = (int) idxStore.nextId(); PropertyKeyTokenRecord record = new PropertyKeyTokenRecord(keyId); record.setInUse(true); record.setCreated(); Collection<DynamicRecord> keyRecords = idxStore.allocateNameRecords(encodeString(stringKey)); record.setNameId((int) first(keyRecords).getId()); record.addNameRecords(keyRecords); idxStore.updateRecord(record); propertyKeyTokens.addToken(stringKey, keyId); return keyId; }
private int createNewRelationshipType(String name) { RelationshipTypeTokenStore typeStore = getRelationshipTypeStore(); int id = (int) typeStore.nextId(); RelationshipTypeTokenRecord record = new RelationshipTypeTokenRecord(id); record.setInUse(true); record.setCreated(); Collection<DynamicRecord> nameRecords = typeStore.allocateNameRecords(encodeString(name)); record.setNameId((int) first(nameRecords).getId()); record.addNameRecords(nameRecords); typeStore.updateRecord(record); relationshipTypeTokens.addToken(name, id); return id; }
private int createNewLabelId(String stringKey) { LabelTokenStore labelTokenStore = neoStore.getLabelTokenStore(); int keyId = (int) labelTokenStore.nextId(); LabelTokenRecord record = new LabelTokenRecord(keyId); record.setInUse(true); record.setCreated(); Collection<DynamicRecord> keyRecords = labelTokenStore.allocateNameRecords(encodeString(stringKey)); record.setNameId((int) first(keyRecords).getId()); record.addNameRecords(keyRecords); labelTokenStore.updateRecord(record); labelTokens.addToken(stringKey, keyId); return keyId; }
private long createPropertyChain(Map<String, Object> properties) { if (properties == null || properties.isEmpty()) { return Record.NO_NEXT_PROPERTY.intValue(); } PropertyStore propStore = getPropertyStore(); List<PropertyRecord> propRecords = new ArrayList<>(); PropertyRecord currentRecord = new PropertyRecord(propStore.nextId()); currentRecord.setInUse(true); currentRecord.setCreated(); propRecords.add(currentRecord); for (Entry<String, Object> entry : properties.entrySet()) { int keyId = propertyKeyTokens.idOf(entry.getKey()); if (keyId == -1) { keyId = createNewPropertyKeyId(entry.getKey()); } PropertyBlock block = new PropertyBlock(); propStore.encodeValue(block, keyId, entry.getValue()); if (currentRecord.size() + block.getSize() > PropertyType.getPayloadSize()) { // Here it means the current block is done for PropertyRecord prevRecord = currentRecord; // Create new record long propertyId = propStore.nextId(); currentRecord = new PropertyRecord(propertyId); currentRecord.setInUse(true); currentRecord.setCreated(); // Set up links prevRecord.setNextProp(propertyId); currentRecord.setPrevProp(prevRecord.getId()); propRecords.add(currentRecord); // Now current is ready to start picking up blocks } currentRecord.addPropertyBlock(block); } /* * Add the property records in reverse order, which means largest * id first. That is to make sure we expand the property store file * only once. */ for (int i = propRecords.size() - 1; i >= 0; i--) { propStore.updateRecord(propRecords.get(i)); } /* * 0 will always exist, if the map was empty we wouldn't be here * and even one property will create at least one record. */ return propRecords.get(0).getId(); }
private boolean primitiveHasProperty(PrimitiveRecord record, String propertyName) { long nextProp = record.getNextProp(); int propertyKeyId = propertyKeyTokens.idOf(propertyName); if (nextProp == Record.NO_NEXT_PROPERTY.intValue() || propertyKeyId == -1) { return false; } PropertyRecord current; while (nextProp != Record.NO_NEXT_PROPERTY.intValue()) { current = getPropertyStore().getRecord(nextProp); if (current.getPropertyBlock(propertyKeyId) != null) { return true; } nextProp = current.getNextProp(); } return false; }
private Map<String, Object> getPropertyChain(long nextProp) { PropertyStore propStore = getPropertyStore(); Map<String, Object> properties = new HashMap<>(); while (nextProp != Record.NO_NEXT_PROPERTY.intValue()) { PropertyRecord propRecord = propStore.getRecord(nextProp); for (PropertyBlock propBlock : propRecord.getPropertyBlocks()) { String key = propertyKeyTokens.nameOf(propBlock.getKeyIndexId()); DefinedProperty propertyData = propBlock.newPropertyData(propStore); Object value = propertyData.value() != null ? propertyData.value() : propBlock.getType().getValue(propBlock, getPropertyStore()); properties.put(key, value); } nextProp = propRecord.getNextProp(); } return properties; }
@Override public long createRelationship( long node1, long node2, RelationshipType type, Map<String, Object> properties) { NodeRecord firstNode = getNodeRecord(node1); NodeRecord secondNode = getNodeRecord(node2); int typeId = relationshipTypeTokens.idOf(type.name()); if (typeId == -1) { typeId = createNewRelationshipType(type.name()); } long id = getRelationshipStore().nextId(); RelationshipRecord record = new RelationshipRecord(id, node1, node2, typeId); record.setInUse(true); record.setCreated(); connectRelationship(firstNode, secondNode, record); getNodeStore().updateRecord(firstNode); getNodeStore().updateRecord(secondNode); record.setNextProp(createPropertyChain(properties)); getRelationshipStore().updateRecord(record); return id; }
@Override public Label apply(long from) { return label(labelTokens.nameOf(safeCastLongToInt(from))); }
public int getLabelId(String name) { return labelTokens.idOf(name); }
public int getRelTypeId(String name) { return relationshipTypeTokens.idOf(name); }
private int getPropertyKeyId(String name) { return propertyKeyTokens.idOf(name); }
private int getLabelId(String name) { return labelTokens.idOf(name); }