public virtual void CreateToken(string name, long id, RecordAccess <R, Void> recordAccess)
{
R record = recordAccess.Create(id, null).forChangingData();
record.InUse = true;
record.setCreated();
ICollection <DynamicRecord> nameRecords = _store.allocateNameRecords(encodeString(name));
record.NameId = ( int )Iterables.first(nameRecords).Id;
record.addNameRecords(nameRecords);
}
private long CreatePropertyChain(PrimitiveRecord owner, IEnumerator <PropertyBlock> properties, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords, System.Action <PropertyRecord> createdPropertyRecords)
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
if (properties == null || !properties.hasNext())
{
return(Record.NO_NEXT_PROPERTY.intValue());
}
PropertyRecord currentRecord = propertyRecords.Create(_propertyRecordIdGenerator.nextId(), owner).forChangingData();
createdPropertyRecords(currentRecord);
currentRecord.InUse = true;
currentRecord.SetCreated();
PropertyRecord firstRecord = currentRecord;
while (properties.MoveNext())
{
PropertyBlock block = properties.Current;
if (currentRecord.Size() + block.Size > PropertyType.PayloadSize)
{
// Here it means the current block is done for
PropertyRecord prevRecord = currentRecord;
// Create new record
long propertyId = _propertyRecordIdGenerator.nextId();
currentRecord = propertyRecords.Create(propertyId, owner).forChangingData();
createdPropertyRecords(currentRecord);
currentRecord.InUse = true;
currentRecord.SetCreated();
// Set up links
prevRecord.NextProp = propertyId;
currentRecord.PrevProp = prevRecord.Id;
// Now current is ready to start picking up blocks
}
currentRecord.AddPropertyBlock(block);
}
return(firstRecord.Id);
}
public virtual RecordAccess_RecordProxy <RelationshipGroupRecord, int> GetOrCreateRelationshipGroup(NodeRecord node, int type, RecordAccess <RelationshipGroupRecord, int> relGroupRecords)
{
RelationshipGroupPosition existingGroup = GetRelationshipGroup(node, type, relGroupRecords);
RecordAccess_RecordProxy <RelationshipGroupRecord, int> change = existingGroup.Group();
if (change == null)
{
Debug.Assert(node.Dense, "Node " + node + " should have been dense at this point");
long id = _idGenerator.nextId();
change = relGroupRecords.Create(id, type);
RelationshipGroupRecord record = change.ForChangingData();
record.InUse = true;
record.SetCreated();
record.OwningNode = node.Id;
// Attach it...
RecordAccess_RecordProxy <RelationshipGroupRecord, int> closestPreviousChange = existingGroup.ClosestPrevious();
if (closestPreviousChange != null)
{ // ...after the closest previous one
RelationshipGroupRecord closestPrevious = closestPreviousChange.ForChangingLinkage();
record.Next = closestPrevious.Next;
record.Prev = closestPrevious.Id;
closestPrevious.Next = id;
}
else
{ // ...first in the chain
long firstGroupId = node.NextRel;
if (firstGroupId != Record.NO_NEXT_RELATIONSHIP.intValue())
{ // There are others, make way for this new group
RelationshipGroupRecord previousFirstRecord = relGroupRecords.GetOrLoad(firstGroupId, type).forReadingData();
record.Next = previousFirstRecord.Id;
previousFirstRecord.Prev = id;
}
node.NextRel = id;
}
}
return(change);
}
public virtual void PrimitiveSetProperty <P>(RecordAccess_RecordProxy <P, Void> primitiveRecordChange, int propertyKey, Value value, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords) where P : Org.Neo4j.Kernel.impl.store.record.PrimitiveRecord
{
PropertyBlock block = EncodePropertyValue(propertyKey, value);
P primitive = primitiveRecordChange.ForReadingLinkage();
Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords));
int newBlockSizeInBytes = block.Size;
// Traverse the existing property chain. Tracking two things along the way:
// - (a) Free space for this block (candidateHost)
// - (b) Existence of a block with the property key
// Chain traversal can be aborted only if:
// - (1) (b) occurs and new property block fits where the current is
// - (2) (a) occurs and (b) has occurred, but new property block didn't fit
// - (3) (b) occurs and (a) has occurred
// - (4) Chain ends
RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> freeHostProxy = null;
RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> existingHostProxy = null;
long prop = primitive.NextProp;
while (prop != Record.NO_NEXT_PROPERTY.intValue()) // <-- (4)
{
RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> proxy = propertyRecords.GetOrLoad(prop, primitive);
PropertyRecord propRecord = proxy.ForReadingLinkage();
Debug.Assert(propRecord.InUse(), propRecord);
// (a) search for free space
if (PropertyFitsInside(newBlockSizeInBytes, propRecord))
{
freeHostProxy = proxy;
if (existingHostProxy != null)
{
// (2)
PropertyRecord freeHost = proxy.ForChangingData();
freeHost.AddPropertyBlock(block);
freeHost.Changed = primitive;
Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords));
return;
}
}
// (b) search for existence of property key
PropertyBlock existingBlock = propRecord.GetPropertyBlock(propertyKey);
if (existingBlock != null)
{
// We found an existing property and whatever happens we have to remove the existing
// block so that we can add the new one, where ever we decide to place it
existingHostProxy = proxy;
PropertyRecord existingHost = existingHostProxy.ForChangingData();
RemoveProperty(primitive, existingHost, existingBlock);
// Now see if we at this point can add the new block
if (newBlockSizeInBytes <= existingBlock.Size || PropertyFitsInside(newBlockSizeInBytes, existingHost)) // fallback check
{
// (1) yes we could add it right into the host of the existing block
existingHost.AddPropertyBlock(block);
Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords));
return;
}
else if (freeHostProxy != null)
{
// (3) yes we could add it to a previously found host with sufficiently free space in it
PropertyRecord freeHost = freeHostProxy.ForChangingData();
freeHost.AddPropertyBlock(block);
freeHost.Changed = primitive;
Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords));
return;
}
// else we can't add it at this point
}
// Continue down the chain
prop = propRecord.NextProp;
}
// At this point we haven't added the property block, although we may have found room for it
// along the way. If we didn't then just create a new record, it's fine
PropertyRecord freeHost;
if (freeHostProxy == null)
{
// We couldn't find free space along the way, so create a new host record
freeHost = propertyRecords.Create(_propertyRecordIdGenerator.nextId(), primitive).forChangingData();
freeHost.InUse = true;
if (primitive.NextProp != Record.NO_NEXT_PROPERTY.intValue())
{
// This isn't the first property record for the entity, re-shuffle the first one so that
// the new one becomes the first
PropertyRecord prevProp = propertyRecords.GetOrLoad(primitive.NextProp, primitive).forChangingLinkage();
Debug.Assert(prevProp.PrevProp == Record.NO_PREVIOUS_PROPERTY.intValue());
prevProp.PrevProp = freeHost.Id;
freeHost.NextProp = prevProp.Id;
prevProp.Changed = primitive;
}
// By the way, this is the only condition where the primitive record also needs to change
primitiveRecordChange.ForChangingLinkage().NextProp = freeHost.Id;
}
else
{
freeHost = freeHostProxy.ForChangingData();
}
// At this point we know that we have a host record with sufficient space in it for the block
// to add, so simply add it
freeHost.AddPropertyBlock(block);
Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords));
}
