/// <summary> /// Removes property with given {@code propertyKey} from property chain owner by the primitive found in /// {@code primitiveProxy}. /// </summary> /// <param name="primitiveProxy"> access to the primitive record pointing to the start of the property chain. </param> /// <param name="propertyKey"> the property key token id to look for and remove. </param> /// <param name="propertyRecords"> access to records. </param> /// <exception cref="IllegalStateException"> if property key was not found in the property chain. </exception> public virtual void RemoveProperty <P>(RecordAccess_RecordProxy <P, Void> primitiveProxy, int propertyKey, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords) where P : Org.Neo4j.Kernel.impl.store.record.PrimitiveRecord { PrimitiveRecord primitive = primitiveProxy.ForReadingData(); long propertyId = _traverser.findPropertyRecordContaining(primitive, propertyKey, propertyRecords, true); RemoveProperty(primitiveProxy, propertyKey, propertyRecords, primitive, propertyId); }
private void RemoveProperty(PrimitiveRecord primitive, PropertyRecord host, PropertyBlock block) { host.RemovePropertyBlock(block.KeyIndexId); host.Changed = primitive; foreach (DynamicRecord record in block.ValueRecords) { Debug.Assert(record.InUse()); record.SetInUse(false, block.Type.intValue()); host.AddDeletedRecord(record); } }
/// <summary> /// Removes property with given {@code propertyKey} from property chain owner by the primitive found in /// {@code primitiveProxy} if it exists. /// </summary> /// <param name="primitiveProxy"> access to the primitive record pointing to the start of the property chain. </param> /// <param name="propertyKey"> the property key token id to look for and remove. </param> /// <param name="propertyRecords"> access to records. </param> /// <returns> {@code true} if the property was found and removed, otherwise {@code false}. </returns> public virtual bool RemovePropertyIfExists <P>(RecordAccess_RecordProxy <P, Void> primitiveProxy, int propertyKey, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords) where P : Org.Neo4j.Kernel.impl.store.record.PrimitiveRecord { PrimitiveRecord primitive = primitiveProxy.ForReadingData(); long propertyId = _traverser.findPropertyRecordContaining(primitive, propertyKey, propertyRecords, false); if (!Record.NO_NEXT_PROPERTY.@is(propertyId)) { RemoveProperty(primitiveProxy, propertyKey, propertyRecords, primitive, propertyId); return(true); } return(false); }
public virtual void DeletePropertyChain(PrimitiveRecord primitive, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords) { long nextProp = primitive.NextProp; while (nextProp != Record.NO_NEXT_PROPERTY.intValue()) { RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> propertyChange = propertyRecords.GetOrLoad(nextProp, primitive); // TODO forChanging/forReading piggy-backing PropertyRecord propRecord = propertyChange.ForChangingData(); DeletePropertyRecordIncludingValueRecords(propRecord); nextProp = propRecord.NextProp; propRecord.Changed = primitive; } primitive.NextProp = Record.NO_NEXT_PROPERTY.intValue(); }
/// <summary> /// Traverses a property record chain and finds the record containing the property with key {@code propertyKey}. /// If none is found and {@code strict} is {@code true} then <seealso cref="System.InvalidOperationException"/> is thrown, /// otherwise id value of <seealso cref="Record.NO_NEXT_PROPERTY"/> is returned. /// </summary> /// <param name="primitive"> <seealso cref="PrimitiveRecord"/> which is the owner of the chain. </param> /// <param name="propertyKey"> property key token id to look for. </param> /// <param name="propertyRecords"> access to records. </param> /// <param name="strict"> dictates behavior on property key not found. If {@code true} then <seealso cref="System.InvalidOperationException"/> /// is thrown, otherwise value of <seealso cref="Record.NO_NEXT_PROPERTY"/> is returned. </param> /// <returns> property record id containing property with the given {@code propertyKey}, otherwise if /// {@code strict} is false value of <seealso cref="Record.NO_NEXT_PROPERTY"/>. </returns> public virtual long FindPropertyRecordContaining(PrimitiveRecord primitive, int propertyKey, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords, bool strict) { long propertyRecordId = primitive.NextProp; while (!Record.NO_NEXT_PROPERTY.@is(propertyRecordId)) { PropertyRecord propertyRecord = propertyRecords.GetOrLoad(propertyRecordId, primitive).forReadingLinkage(); if (propertyRecord.GetPropertyBlock(propertyKey) != null) { return(propertyRecordId); } propertyRecordId = propertyRecord.NextProp; } if (strict) { throw new System.InvalidOperationException("No property record in property chain for " + primitive + " contained property with key " + propertyKey); } return(Record.NO_NEXT_PROPERTY.intValue()); }
public virtual bool AssertPropertyChain(PrimitiveRecord primitive, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords) { IList <PropertyRecord> toCheck = new LinkedList <PropertyRecord>(); long nextIdToFetch = primitive.NextProp; while (nextIdToFetch != Record.NO_NEXT_PROPERTY.intValue()) { PropertyRecord propRecord = propertyRecords.GetOrLoad(nextIdToFetch, primitive).forReadingLinkage(); toCheck.Add(propRecord); Debug.Assert(propRecord.InUse(), primitive + "->"); +Arrays.ToString(toCheck.ToArray()); Debug.Assert(propRecord.Size() <= PropertyType.PayloadSize, propRecord + " size " + propRecord.Size()); nextIdToFetch = propRecord.NextProp; } if (toCheck.Count == 0) { Debug.Assert(primitive.NextProp == Record.NO_NEXT_PROPERTY.intValue(), primitive); return(true); } PropertyRecord first = toCheck[0]; PropertyRecord last = toCheck[toCheck.Count - 1]; Debug.Assert(first.PrevProp == Record.NO_PREVIOUS_PROPERTY.intValue(), primitive + "->"); +Arrays.ToString(toCheck.ToArray()); Debug.Assert(last.NextProp == Record.NO_NEXT_PROPERTY.intValue(), primitive + "->"); +Arrays.ToString(toCheck.ToArray()); PropertyRecord current; PropertyRecord previous = first; for (int i = 1; i < toCheck.Count; i++) { current = toCheck[i]; Debug.Assert(current.PrevProp == previous.Id, primitive + "->"); +Arrays.ToString(toCheck.ToArray()); Debug.Assert(previous.NextProp == current.Id, primitive + "->"); +Arrays.ToString(toCheck.ToArray()); previous = current; } return(true); }
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 long CreatePropertyChain(PrimitiveRecord owner, IEnumerator <PropertyBlock> properties, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords) { return(CreatePropertyChain(owner, properties, propertyRecords, p => { })); }
private void RemoveProperty <P>(RecordAccess_RecordProxy <P, Void> primitiveProxy, int propertyKey, RecordAccess <PropertyRecord, PrimitiveRecord> propertyRecords, PrimitiveRecord primitive, long propertyId) where P : Org.Neo4j.Kernel.impl.store.record.PrimitiveRecord { RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> recordChange = propertyRecords.GetOrLoad(propertyId, primitive); PropertyRecord propRecord = recordChange.ForChangingData(); if (!propRecord.InUse()) { throw new System.InvalidOperationException("Unable to delete property[" + propertyId + "] since it is already deleted."); } PropertyBlock block = propRecord.RemovePropertyBlock(propertyKey); if (block == null) { throw new System.InvalidOperationException("Property with index[" + propertyKey + "] is not present in property[" + propertyId + "]"); } foreach (DynamicRecord valueRecord in block.ValueRecords) { Debug.Assert(valueRecord.InUse()); valueRecord.SetInUse(false, block.Type.intValue()); propRecord.AddDeletedRecord(valueRecord); } if (propRecord.Size() > 0) { /* * There are remaining blocks in the record. We do not unlink yet. */ propRecord.Changed = primitive; Debug.Assert(_traverser.assertPropertyChain(primitive, propertyRecords)); } else { UnlinkPropertyRecord(propRecord, propertyRecords, primitiveProxy); } }
private Command.PropertyCommand Property(PrimitiveRecord owner) { long propertyId = _nextPropertyId++; return(new Command.PropertyCommand(new PropertyRecord(propertyId, owner), new PropertyRecord(propertyId, owner))); }