//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReadACommandLogEntry() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldReadACommandLogEntry() { // given LogEntryVersion version = LogEntryVersion.CURRENT; Command.NodeCommand nodeCommand = new Command.NodeCommand(new NodeRecord(11), new NodeRecord(11)); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LogEntryCommand command = new LogEntryCommand(version, nodeCommand); LogEntryCommand command = new LogEntryCommand(version, nodeCommand); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.InMemoryClosableChannel channel = new org.neo4j.kernel.impl.transaction.log.InMemoryClosableChannel(); InMemoryClosableChannel channel = new InMemoryClosableChannel(); channel.Put(version.byteCode()); channel.Put(LogEntryByteCodes.Command); nodeCommand.Serialize(channel); // when //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LogEntry logEntry = logEntryReader.readLogEntry(channel); LogEntry logEntry = _logEntryReader.readLogEntry(channel); // then assertEquals(command, logEntry); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldContainFedNodeUpdate() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldContainFedNodeUpdate() { OnlineIndexUpdates onlineIndexUpdates = new OnlineIndexUpdates(_nodeStore, _relationshipStore, _indexingService, _propertyPhysicalToLogicalConverter); int nodeId = 0; NodeRecord inUse = GetNode(nodeId, true); Value propertyValue = Values.of("hej"); long propertyId = CreateNodeProperty(inUse, propertyValue, 1); NodeRecord notInUse = GetNode(nodeId, false); _nodeStore.updateRecord(inUse); Command.NodeCommand nodeCommand = new Command.NodeCommand(inUse, notInUse); PropertyRecord propertyBlocks = new PropertyRecord(propertyId); propertyBlocks.NodeId = nodeId; Command.PropertyCommand propertyCommand = new Command.PropertyCommand(_recordAccess.getIfLoaded(propertyId).forReadingData(), propertyBlocks); StoreIndexDescriptor indexDescriptor = forSchema(multiToken(_entityTokens, NODE, 1, 4, 6), EMPTY.ProviderDescriptor).withId(0); _indexingService.createIndexes(indexDescriptor); _indexingService.getIndexProxy(indexDescriptor.Schema()).awaitStoreScanCompleted(0, MILLISECONDS); onlineIndexUpdates.Feed(NodeGroup(nodeCommand, propertyCommand), RelationshipGroup(null)); 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(nodeId, 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()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertSerializationWorksFor(org.neo4j.kernel.impl.transaction.command.Command.NodeCommand cmd) throws java.io.IOException private void AssertSerializationWorksFor(Command.NodeCommand cmd) { _channel.reset(); cmd.Serialize(_channel); Command.NodeCommand result = (Command.NodeCommand)_commandReader.read(_channel); // Then assertThat(result, equalTo(cmd)); assertThat(result.Mode, equalTo(cmd.Mode)); assertThat(result.Before, equalTo(cmd.Before)); assertThat(result.After, equalTo(cmd.After)); // And created and dense flags should be the same assertThat(result.Before.Created, equalTo(cmd.Before.Created)); assertThat(result.After.Created, equalTo(cmd.After.Created)); assertThat(result.Before.Dense, equalTo(cmd.Before.Dense)); assertThat(result.After.Dense, equalTo(cmd.After.Dense)); // And labels should be the same assertThat(Labels(result.Before), equalTo(Labels(cmd.Before))); assertThat(Labels(result.After), equalTo(Labels(cmd.After))); // And dynamic records should be the same assertThat(result.Before.DynamicLabelRecords, equalTo(cmd.Before.DynamicLabelRecords)); assertThat(result.After.DynamicLabelRecords, equalTo(cmd.After.DynamicLabelRecords)); // And the secondary unit information should be the same // Before assertThat(result.Before.requiresSecondaryUnit(), equalTo(cmd.Before.requiresSecondaryUnit())); assertThat(result.Before.hasSecondaryUnitId(), equalTo(cmd.Before.hasSecondaryUnitId())); assertThat(result.Before.SecondaryUnitId, equalTo(cmd.Before.SecondaryUnitId)); // and after assertThat(result.After.requiresSecondaryUnit(), equalTo(cmd.After.requiresSecondaryUnit())); assertThat(result.After.hasSecondaryUnitId(), equalTo(cmd.After.hasSecondaryUnitId())); assertThat(result.After.SecondaryUnitId, equalTo(cmd.After.SecondaryUnitId)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSerializeDynamicRecordsRemoved() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSerializeDynamicRecordsRemoved() { _channel.reset(); // Given NodeRecord before = new NodeRecord(12, false, 1, 2); before.InUse = true; IList <DynamicRecord> beforeDyn = singletonList(dynamicRecord(0, true, true, -1L, LONG.intValue(), new sbyte[] { 1, 2, 3, 4, 5, 6, 7, 8 })); before.SetLabelField(dynamicPointer(beforeDyn), beforeDyn); NodeRecord after = new NodeRecord(12, false, 2, 1); after.InUse = true; IList <DynamicRecord> dynamicRecords = singletonList(dynamicRecord(0, false, true, -1L, LONG.intValue(), new sbyte[] { 1, 2, 3, 4, 5, 6, 7, 8 })); after.SetLabelField(dynamicPointer(dynamicRecords), dynamicRecords); // When Command.NodeCommand cmd = new Command.NodeCommand(before, after); cmd.Serialize(_channel); Command.NodeCommand result = (Command.NodeCommand)_commandReader.read(_channel); // Then assertThat(result, equalTo(cmd)); assertThat(result.Mode, equalTo(cmd.Mode)); assertThat(result.Before, equalTo(cmd.Before)); assertThat(result.After, equalTo(cmd.After)); // And dynamic records should be the same assertThat(result.Before.DynamicLabelRecords, equalTo(cmd.Before.DynamicLabelRecords)); assertThat(result.After.DynamicLabelRecords, equalTo(cmd.After.DynamicLabelRecords)); }
public override bool VisitNodeCommand(Command.NodeCommand command) { if (!NodeVisited) { Updated = false; Deleted = false; } NodeVisited = true; switch (command.Mode) { case CREATE: assertFalse(Updated); assertFalse(Deleted); break; case UPDATE: Updated = true; assertFalse(Deleted); break; case DELETE: Deleted = true; break; default: throw new System.InvalidOperationException("Unknown command mode: " + command.Mode); } return(false); }
protected internal virtual TransactionToApply Tx() { NodeRecord before = new NodeRecord(0); NodeRecord after = new NodeRecord(0); after.InUse = true; Command.NodeCommand nodeCommand = new Command.NodeCommand(before, after); PhysicalTransactionRepresentation tx = new PhysicalTransactionRepresentation(singletonList(nodeCommand)); tx.SetHeader(new sbyte[0], 0, 0, 0, 0, 0, 0); return(new TransactionToApply(tx)); }
private void GatherUpdatesFor(long nodeId, Command.NodeCommand nodeCommand, EntityCommandGrouper <Command.NodeCommand> .Cursor propertyCommands) { EntityUpdates.Builder nodePropertyUpdate = GatherUpdatesFromCommandsForNode(nodeId, nodeCommand, propertyCommands); EntityUpdates entityUpdates = nodePropertyUpdate.Build(); // we need to materialize the IndexEntryUpdates here, because when we // consume (later in separate thread) the store might have changed. foreach (IndexEntryUpdate <SchemaDescriptor> update in _updateService.convertToIndexUpdates(entityUpdates, EntityType.NODE)) { _updates.Add(update); } }
//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))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSerializeSecondaryUnitUsage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSerializeSecondaryUnitUsage() { // Given // a record that is changed to include a secondary unit NodeRecord before = new NodeRecord(13, false, 1, 2); before.InUse = true; before.RequiresSecondaryUnit = false; before.SecondaryUnitId = NO_ID; // this and the previous line set the defaults, they are here for clarity NodeRecord after = new NodeRecord(13, false, 1, 2); after.InUse = true; after.RequiresSecondaryUnit = true; after.SecondaryUnitId = 14L; Command.NodeCommand command = new Command.NodeCommand(before, after); // Then AssertSerializationWorksFor(command); }
private EntityUpdates.Builder GatherUpdatesFromCommandsForNode(long nodeId, Command.NodeCommand nodeChanges, EntityCommandGrouper <Command.NodeCommand> .Cursor propertyCommandsForNode) { long[] nodeLabelsBefore; long[] nodeLabelsAfter; if (nodeChanges != null) { nodeLabelsBefore = parseLabelsField(nodeChanges.Before).get(_nodeStore); nodeLabelsAfter = parseLabelsField(nodeChanges.After).get(_nodeStore); } else { /* If the node doesn't exist here then we've most likely encountered this scenario: * - TX1: Node N exists and has property record P * - rotate log * - TX2: P gets changed * - TX3: N gets deleted (also P, but that's irrelevant for this scenario) * - N is persisted to disk for some reason * - crash * - recover * - TX2: P has changed and updates to indexes are gathered. As part of that it tries to read * the labels of N (which does not exist a.t.m.). * * We can actually (if we disregard any potential inconsistencies) just assume that * if this happens and we're in recovery mode that the node in question will be deleted * in an upcoming transaction, so just skip this update. */ NodeRecord nodeRecord = LoadNode(nodeId); nodeLabelsBefore = nodeLabelsAfter = parseLabelsField(nodeRecord).get(_nodeStore); } // First get possible Label changes bool complete = ProvidesCompleteListOfProperties(nodeChanges); EntityUpdates.Builder nodePropertyUpdates = EntityUpdates.forEntity(nodeId, complete).withTokens(nodeLabelsBefore).withTokensAfter(nodeLabelsAfter); // Then look for property changes _converter.convertPropertyRecord(propertyCommandsForNode, nodePropertyUpdates); return(nodePropertyUpdates); }
//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; }
private EntityCommandGrouper <Command.NodeCommand> .Cursor NodeGroup(Command.NodeCommand nodeCommand, params Command.PropertyCommand[] propertyCommands) { return(Group(nodeCommand, typeof(Command.NodeCommand), propertyCommands)); }