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);
}
