//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldContainFedRelationshipUpdate() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldContainFedRelationshipUpdate()
{
OnlineIndexUpdates onlineIndexUpdates = new OnlineIndexUpdates(_nodeStore, _relationshipStore, _indexingService, _propertyPhysicalToLogicalConverter);
long relId = 0;
RelationshipRecord inUse = GetRelationship(relId, true, ENTITY_TOKEN);
Value propertyValue = Values.of("hej");
long propertyId = CreateRelationshipProperty(inUse, propertyValue, 1);
RelationshipRecord notInUse = GetRelationship(relId, false, ENTITY_TOKEN);
_relationshipStore.updateRecord(inUse);
Command.RelationshipCommand relationshipCommand = new Command.RelationshipCommand(inUse, notInUse);
PropertyRecord propertyBlocks = new PropertyRecord(propertyId);
propertyBlocks.RelId = relId;
Command.PropertyCommand propertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(propertyId).forReadingData(), propertyBlocks);
StoreIndexDescriptor indexDescriptor = forSchema(multiToken(_entityTokens, RELATIONSHIP, 1, 4, 6), EMPTY.ProviderDescriptor).withId(0);
_indexingService.createIndexes(indexDescriptor);
_indexingService.getIndexProxy(indexDescriptor.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
onlineIndexUpdates.Feed(NodeGroup(null), RelationshipGroup(relationshipCommand, propertyCommand));
assertTrue(onlineIndexUpdates.HasUpdates());
IEnumerator <IndexEntryUpdate <SchemaDescriptor> > iterator = onlineIndexUpdates.GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertEquals(iterator.next(), IndexEntryUpdate.remove(relId, indexDescriptor, propertyValue, null, null));
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertFalse(iterator.hasNext());
}
private void MapBlocks <T1>(EntityCommandGrouper <T1> changes)
{
_beforeBlocksCursor = 0;
_afterBlocksCursor = 0;
while (true)
{
Command.PropertyCommand change = changes.nextProperty();
if (change == null)
{
break;
}
foreach (PropertyBlock block in change.Before)
{
if (_beforeBlocksCursor == _beforeBlocks.Length)
{
_beforeBlocks = Arrays.copyOf(_beforeBlocks, _beforeBlocksCursor * 2);
}
_beforeBlocks[_beforeBlocksCursor++] = block;
}
foreach (PropertyBlock block in change.After)
{
if (_afterBlocksCursor == _afterBlocks.Length)
{
_afterBlocks = Arrays.copyOf(_afterBlocks, _afterBlocksCursor * 2);
}
_afterBlocks[_afterBlocksCursor++] = block;
}
}
Arrays.sort(_beforeBlocks, 0, _beforeBlocksCursor, _blockComparator);
Arrays.sort(_afterBlocks, 0, _afterBlocksCursor, _blockComparator);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ParameterizedTest @EnumSource(Factory.class) void shouldWorkOnADifferentSetOfCommandsAfterClear(Factory factory)
internal virtual void ShouldWorkOnADifferentSetOfCommandsAfterClear(Factory factory)
{
// given
EntityCommandGrouper grouper = new EntityCommandGrouper <>(factory.command(0).GetType(), 16);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.kernel.impl.transaction.command.Command.BaseCommand<? extends org.neo4j.kernel.impl.store.record.PrimitiveRecord> entity0 = factory.command(0);
Command.BaseCommand <PrimitiveRecord> entity0 = factory.command(0);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.kernel.impl.transaction.command.Command.BaseCommand<? extends org.neo4j.kernel.impl.store.record.PrimitiveRecord> entity1 = factory.command(1);
Command.BaseCommand <PrimitiveRecord> entity1 = factory.command(1);
grouper.add(entity0);
grouper.add(entity1);
grouper.add(Property(entity0.After));
grouper.add(Property(entity1.After));
grouper.clear();
// when
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.kernel.impl.transaction.command.Command.BaseCommand<? extends org.neo4j.kernel.impl.store.record.PrimitiveRecord> entity2 = factory.command(2);
Command.BaseCommand <PrimitiveRecord> entity2 = factory.command(2);
Command.PropertyCommand entityProperty = Property(entity2.After);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.kernel.impl.transaction.command.Command.BaseCommand<? extends org.neo4j.kernel.impl.store.record.PrimitiveRecord> entity3 = factory.command(3);
Command.BaseCommand <PrimitiveRecord> entity3 = factory.command(3);
grouper.add(entity2);
grouper.add(entityProperty);
grouper.add(entity3);
// then
AssertGroups(grouper.sortAndAccessGroups(), Group(entity2.Key, entity2, entityProperty), Group(entity3.Key, entity3));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ParameterizedTest @EnumSource(Factory.class) void shouldSeeMultipleGroupsSomeOfThemWithEntity(Factory factory)
internal virtual void ShouldSeeMultipleGroupsSomeOfThemWithEntity(Factory factory)
{
// given
EntityCommandGrouper grouper = new EntityCommandGrouper <>(factory.command(0).GetType(), 64);
Group[] groups = new Group[_random.Next(10, 30)];
for (int entityId = 0; entityId < groups.Length; entityId++)
{
Command.BaseCommand entityCommand = _random.nextBoolean() ? factory.command(entityId) : null;
groups[entityId] = new Group(entityId, entityCommand);
if (entityCommand != null)
{
grouper.add(entityCommand); // <-- storage transaction logs are sorted such that entity commands comes before property commands
}
}
int totalNumberOfProperties = _random.Next(10, 100);
for (int i = 0; i < totalNumberOfProperties; i++)
{
int entityId = _random.Next(groups.Length);
Command.PropertyCommand property = property(factory.command(entityId).After);
groups[entityId].AddProperty(property);
grouper.add(property);
}
// ^^^ OK so we've generated property commands for random entities in random order, let's sort them
EntityCommandGrouper.Cursor cursor = grouper.sortAndAccessGroups();
// then
AssertGroups(cursor, groups);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDifferentiateNodesAndRelationships() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldDifferentiateNodesAndRelationships()
{
OnlineIndexUpdates onlineIndexUpdates = new OnlineIndexUpdates(_nodeStore, _relationshipStore, _indexingService, _propertyPhysicalToLogicalConverter);
int nodeId = 0;
NodeRecord inUseNode = GetNode(nodeId, true);
Value nodePropertyValue = Values.of("hej");
long nodePropertyId = CreateNodeProperty(inUseNode, nodePropertyValue, 1);
NodeRecord notInUseNode = GetNode(nodeId, false);
_nodeStore.updateRecord(inUseNode);
Command.NodeCommand nodeCommand = new Command.NodeCommand(inUseNode, notInUseNode);
PropertyRecord nodePropertyBlocks = new PropertyRecord(nodePropertyId);
nodePropertyBlocks.NodeId = nodeId;
Command.PropertyCommand nodePropertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(nodePropertyId).forReadingData(), nodePropertyBlocks);
StoreIndexDescriptor nodeIndexDescriptor = forSchema(multiToken(_entityTokens, NODE, 1, 4, 6), EMPTY.ProviderDescriptor).withId(0);
_indexingService.createIndexes(nodeIndexDescriptor);
_indexingService.getIndexProxy(nodeIndexDescriptor.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
long relId = 0;
RelationshipRecord inUse = GetRelationship(relId, true, ENTITY_TOKEN);
Value relationshipPropertyValue = Values.of("da");
long propertyId = CreateRelationshipProperty(inUse, relationshipPropertyValue, 1);
RelationshipRecord notInUse = GetRelationship(relId, false, ENTITY_TOKEN);
_relationshipStore.updateRecord(inUse);
Command.RelationshipCommand relationshipCommand = new Command.RelationshipCommand(inUse, notInUse);
PropertyRecord relationshipPropertyBlocks = new PropertyRecord(propertyId);
relationshipPropertyBlocks.RelId = relId;
Command.PropertyCommand relationshipPropertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(propertyId).forReadingData(), relationshipPropertyBlocks);
StoreIndexDescriptor relationshipIndexDescriptor = forSchema(multiToken(_entityTokens, RELATIONSHIP, 1, 4, 6), EMPTY.ProviderDescriptor).withId(1);
_indexingService.createIndexes(relationshipIndexDescriptor);
_indexingService.getIndexProxy(relationshipIndexDescriptor.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
onlineIndexUpdates.Feed(NodeGroup(nodeCommand, nodePropertyCommand), RelationshipGroup(relationshipCommand, relationshipPropertyCommand));
assertTrue(onlineIndexUpdates.HasUpdates());
assertThat(onlineIndexUpdates, containsInAnyOrder(IndexEntryUpdate.remove(relId, relationshipIndexDescriptor, relationshipPropertyValue, null, null), IndexEntryUpdate.remove(nodeId, nodeIndexDescriptor, nodePropertyValue, null, null)));
}
internal virtual void AssertGroup(EntityCommandGrouper.Cursor cursor)
{
assertEquals(EntityId, cursor.CurrentEntityId());
assertSame(EntityCommand, cursor.CurrentEntityCommand());
ISet <Command.PropertyCommand> fromGrouper = new HashSet <Command.PropertyCommand>();
while (true)
{
Command.PropertyCommand property = cursor.NextProperty();
if (property == null)
{
break;
}
fromGrouper.Add(property);
}
assertEquals(fromGrouper, Properties);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @ParameterizedTest @EnumSource(Factory.class) void shouldSeeSingleGroupOfPropertiesWithoutEntity(Factory factory)
internal virtual void ShouldSeeSingleGroupOfPropertiesWithoutEntity(Factory factory)
{
// given
EntityCommandGrouper grouper = new EntityCommandGrouper <>(factory.command(0).GetType(), 8);
long entityId = 1;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.kernel.impl.transaction.command.Command.BaseCommand<? extends org.neo4j.kernel.impl.store.record.PrimitiveRecord> entity = factory.command(entityId);
Command.BaseCommand <PrimitiveRecord> entity = factory.command(entityId);
Command.PropertyCommand property1 = Property(entity.After);
Command.PropertyCommand property2 = Property(entity.After);
// intentionally DO NOT add the entity command
grouper.add(property1);
grouper.add(property2);
EntityCommandGrouper.Cursor cursor = grouper.sortAndAccessGroups();
// when/then
AssertGroups(cursor, Group(entityId, null, property1, property2));
}
public virtual bool NextEntity()
{
if (ReadCursor >= outerInstance.writeCursor)
{
return(false);
}
if (outerInstance.commands[ReadCursor].GetType() == outerInstance.entityCommandClass)
{
CurrentEntityCommandConflict = ( ENTITY )outerInstance.commands[ReadCursor++];
CurrentEntity = CurrentEntityCommandConflict.Key;
}
else
{
Command.PropertyCommand firstPropertyCommand = (Command.PropertyCommand)outerInstance.commands[ReadCursor];
CurrentEntityCommandConflict = default(ENTITY);
CurrentEntity = firstPropertyCommand.EntityId;
}
return(true);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldUpdateCorrectIndexes() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldUpdateCorrectIndexes()
{
OnlineIndexUpdates onlineIndexUpdates = new OnlineIndexUpdates(_nodeStore, _relationshipStore, _indexingService, _propertyPhysicalToLogicalConverter);
long relId = 0;
RelationshipRecord inUse = GetRelationship(relId, true, ENTITY_TOKEN);
Value propertyValue = Values.of("hej");
Value propertyValue2 = Values.of("da");
long propertyId = CreateRelationshipProperty(inUse, propertyValue, 1);
long propertyId2 = CreateRelationshipProperty(inUse, propertyValue2, 4);
RelationshipRecord notInUse = GetRelationship(relId, false, ENTITY_TOKEN);
_relationshipStore.updateRecord(inUse);
Command.RelationshipCommand relationshipCommand = new Command.RelationshipCommand(inUse, notInUse);
PropertyRecord propertyBlocks = new PropertyRecord(propertyId);
propertyBlocks.RelId = relId;
Command.PropertyCommand propertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(propertyId).forReadingData(), propertyBlocks);
PropertyRecord propertyBlocks2 = new PropertyRecord(propertyId2);
propertyBlocks2.RelId = relId;
Command.PropertyCommand propertyCommand2 = new Command.PropertyCommand(_recordAccess.getIfLoaded(propertyId2).forReadingData(), propertyBlocks2);
StoreIndexDescriptor indexDescriptor0 = forSchema(multiToken(_entityTokens, RELATIONSHIP, 1, 4, 6), EMPTY.ProviderDescriptor).withId(0);
StoreIndexDescriptor indexDescriptor1 = forSchema(multiToken(_entityTokens, RELATIONSHIP, 2, 4, 6), EMPTY.ProviderDescriptor).withId(1);
StoreIndexDescriptor indexDescriptor2 = forSchema(multiToken(new int[] { ENTITY_TOKEN, OTHER_ENTITY_TOKEN }, RELATIONSHIP, 1), EMPTY.ProviderDescriptor).withId(2);
StoreIndexDescriptor indexDescriptor3 = forSchema(multiToken(new int[] { OTHER_ENTITY_TOKEN }, RELATIONSHIP, 1), EMPTY.ProviderDescriptor).withId(3);
_indexingService.createIndexes(indexDescriptor0, indexDescriptor1, indexDescriptor2);
_indexingService.getIndexProxy(indexDescriptor0.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
_indexingService.getIndexProxy(indexDescriptor1.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
_indexingService.getIndexProxy(indexDescriptor2.Schema()).awaitStoreScanCompleted(0, MILLISECONDS);
onlineIndexUpdates.Feed(NodeGroup(null), RelationshipGroup(relationshipCommand, propertyCommand, propertyCommand2));
assertTrue(onlineIndexUpdates.HasUpdates());
assertThat(onlineIndexUpdates, containsInAnyOrder(IndexEntryUpdate.remove(relId, indexDescriptor0, propertyValue, propertyValue2, null), IndexEntryUpdate.remove(relId, indexDescriptor1, null, propertyValue2, null), IndexEntryUpdate.remove(relId, indexDescriptor2, propertyValue)));
assertThat(onlineIndexUpdates, not(containsInAnyOrder(indexDescriptor3))); // This index is only for a different relationship type.
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void extractCommands(java.util.Collection<org.neo4j.storageengine.api.StorageCommand> commands) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException
public override void ExtractCommands(ICollection <StorageCommand> commands)
{
Debug.Assert(!_prepared, "Transaction has already been prepared");
_integrityValidator.validateTransactionStartKnowledge(_lastCommittedTxWhenTransactionStarted);
int noOfCommands = _recordChangeSet.changeSize() + (_neoStoreRecord != null ? _neoStoreRecord.changeSize() : 0);
foreach (RecordAccess_RecordProxy <LabelTokenRecord, Void> record in _recordChangeSet.LabelTokenChanges.changes())
{
commands.Add(new Command.LabelTokenCommand(record.Before, record.ForReadingLinkage()));
}
foreach (RecordAccess_RecordProxy <RelationshipTypeTokenRecord, Void> record in _recordChangeSet.RelationshipTypeTokenChanges.changes())
{
commands.Add(new Command.RelationshipTypeTokenCommand(record.Before, record.ForReadingLinkage()));
}
foreach (RecordAccess_RecordProxy <PropertyKeyTokenRecord, Void> record in _recordChangeSet.PropertyKeyTokenChanges.changes())
{
commands.Add(new Command.PropertyKeyTokenCommand(record.Before, record.ForReadingLinkage()));
}
// Collect nodes, relationships, properties
Command[] nodeCommands = _emptyCommands;
int skippedCommands = 0;
if (_recordChangeSet.NodeRecords.changeSize() > 0)
{
nodeCommands = new Command[_recordChangeSet.NodeRecords.changeSize()];
int i = 0;
foreach (RecordAccess_RecordProxy <NodeRecord, Void> change in _recordChangeSet.NodeRecords.changes())
{
NodeRecord record = Prepared(change, _nodeStore);
_integrityValidator.validateNodeRecord(record);
nodeCommands[i++] = new Command.NodeCommand(change.Before, record);
}
Arrays.sort(nodeCommands, _commandComparator);
}
Command[] relCommands = _emptyCommands;
if (_recordChangeSet.RelRecords.changeSize() > 0)
{
relCommands = new Command[_recordChangeSet.RelRecords.changeSize()];
int i = 0;
foreach (RecordAccess_RecordProxy <RelationshipRecord, Void> change in _recordChangeSet.RelRecords.changes())
{
relCommands[i++] = new Command.RelationshipCommand(change.Before, Prepared(change, _relationshipStore));
}
Arrays.sort(relCommands, _commandComparator);
}
Command[] propCommands = _emptyCommands;
if (_recordChangeSet.PropertyRecords.changeSize() > 0)
{
propCommands = new Command[_recordChangeSet.PropertyRecords.changeSize()];
int i = 0;
foreach (RecordAccess_RecordProxy <PropertyRecord, PrimitiveRecord> change in _recordChangeSet.PropertyRecords.changes())
{
propCommands[i++] = new Command.PropertyCommand(change.Before, Prepared(change, _propertyStore));
}
Arrays.sort(propCommands, _commandComparator);
}
Command[] relGroupCommands = _emptyCommands;
if (_recordChangeSet.RelGroupRecords.changeSize() > 0)
{
relGroupCommands = new Command[_recordChangeSet.RelGroupRecords.changeSize()];
int i = 0;
foreach (RecordAccess_RecordProxy <RelationshipGroupRecord, int> change in _recordChangeSet.RelGroupRecords.changes())
{
if (change.Created && !change.ForReadingLinkage().inUse())
{
/*
* This is an edge case that may come up and which we must handle properly. Relationship groups are
* not managed by the tx state, since they are created as side effects rather than through
* direct calls. However, they differ from say, dynamic records, in that their management can happen
* through separate code paths. What we are interested in here is the following scenario.
* 0. A node has one less relationship that is required to transition to dense node. The relationships
* it has belong to at least two different types
* 1. In the same tx, a relationship is added making the node dense and all the relationships of a type
* are removed from that node. Regardless of the order these operations happen, the creation of the
* relationship (and the transition of the node to dense) will happen first.
* 2. A relationship group will be created because of the transition to dense and then deleted because
* all the relationships it would hold are no longer there. This results in a relationship group
* command that appears in the tx as not in use. Depending on the final order of operations, this
* can end up using an id that is higher than the highest id seen so far. This may not be a problem
* for a single instance, but it can result in errors in cases where transactions are applied
* externally, such as backup or HA.
*
* The way we deal with this issue here is by not issuing a command for that offending record. This is
* safe, since the record is not in use and never was, so the high id is not necessary to change and
* the store remains consistent.
*/
skippedCommands++;
continue;
}
relGroupCommands[i++] = new Command.RelationshipGroupCommand(change.Before, Prepared(change, _relationshipGroupStore));
}
relGroupCommands = i < relGroupCommands.Length ? Arrays.copyOf(relGroupCommands, i) : relGroupCommands;
Arrays.sort(relGroupCommands, _commandComparator);
}
AddFiltered(commands, Command.Mode.CREATE, propCommands, relCommands, relGroupCommands, nodeCommands);
AddFiltered(commands, Command.Mode.UPDATE, propCommands, relCommands, relGroupCommands, nodeCommands);
AddFiltered(commands, Command.Mode.DELETE, propCommands, relCommands, relGroupCommands, nodeCommands);
if (_neoStoreRecord != null)
{
foreach (RecordAccess_RecordProxy <NeoStoreRecord, Void> change in _neoStoreRecord.changes())
{
commands.Add(new Command.NeoStoreCommand(change.Before, change.ForReadingData()));
}
}
//noinspection unchecked
IList <Command>[] schemaChangeByMode = new System.Collections.IList[Command.Mode.values().length];
for (int i = 0; i < schemaChangeByMode.Length; i++)
{
schemaChangeByMode[i] = new List <Command>();
}
foreach (RecordAccess_RecordProxy <SchemaRecord, SchemaRule> change in _recordChangeSet.SchemaRuleChanges.changes())
{
if (change.ForReadingLinkage().inUse())
{
_integrityValidator.validateSchemaRule(change.AdditionalData);
}
Command.SchemaRuleCommand cmd = new Command.SchemaRuleCommand(change.Before, change.ForChangingData(), change.AdditionalData);
schemaChangeByMode[cmd.Mode.ordinal()].Add(cmd);
}
commands.addAll(schemaChangeByMode[Command.Mode.DELETE.ordinal()]);
commands.addAll(schemaChangeByMode[Command.Mode.CREATE.ordinal()]);
commands.addAll(schemaChangeByMode[Command.Mode.UPDATE.ordinal()]);
Debug.Assert(commands.Count == noOfCommands - skippedCommands, format("Expected %d final commands, got %d " + "instead, with %d skipped", noOfCommands, commands.Count, skippedCommands));
_prepared = true;
}
internal virtual void AddProperty(Command.PropertyCommand property)
{
Properties.Add(property);
}
