//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void before() public virtual void Before() { _config = Config.defaults(); DefaultIdGeneratorFactory idGeneratorFactory = new DefaultIdGeneratorFactory(_fs.get()); _storeFactory = new StoreFactory(_testDirectory.databaseLayout(), _config, idGeneratorFactory, PageCacheRule.getPageCache(_fs.get()), _fs.get(), NullLogProvider.Instance, EmptyVersionContextSupplier.EMPTY); _neoStores = _storeFactory.openAllNeoStores(true); _store = _neoStores.SchemaStore; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public org.neo4j.storageengine.api.schema.SchemaRule loadSingleSchemaRule(long ruleId) throws org.neo4j.internal.kernel.api.exceptions.schema.MalformedSchemaRuleException public override SchemaRule LoadSingleSchemaRule(long ruleId) { ICollection <DynamicRecord> records; try { records = _schemaStore.getRecords(ruleId, RecordLoad.NORMAL); } catch (Exception e) { throw new MalformedSchemaRuleException(e.Message, e); } return(SchemaStore.ReadSchemaRule(ruleId, records, NewRecordBuffer())); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @BeforeClass public static void initStorage() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public static void InitStorage() { using (Transaction transaction = Db.beginTx()) { TokenWrite tokenWrite = Transaction.tokenWrite(); tokenWrite.PropertyKeyGetOrCreateForName(PROP1); tokenWrite.PropertyKeyGetOrCreateForName(PROP2); tokenWrite.LabelGetOrCreateForName(LABEL1); tokenWrite.LabelGetOrCreateForName(LABEL2); tokenWrite.RelationshipTypeGetOrCreateForName(TYPE1); transaction.Success(); } SchemaStore schemaStore = ResolveDependency(typeof(RecordStorageEngine)).testAccessNeoStores().SchemaStore; _storage = new SchemaStorage(schemaStore); }
protected internal override ReturnType fetchNextOrNull() { while (currentId <= highestId) { long id = currentId++; _outerInstance.schemaStore.getRecord(id, record, RecordLoad.FORCE); if (record.inUse() && record.StartRecord) { // It may be that concurrently to our reading there's a transaction dropping the schema rule // that we're reading and that rule may have spanned multiple dynamic records. try { ICollection <DynamicRecord> records; try { records = _outerInstance.schemaStore.getRecords(id, RecordLoad.NORMAL); } catch (InvalidRecordException) { // This may have been due to a concurrent drop of this rule. continue; } SchemaRule schemaRule = SchemaStore.ReadSchemaRule(id, records, scratchData); if (_returnType.IsInstanceOfType(schemaRule)) { ReturnType returnRule = _returnType.cast(schemaRule); if (_predicate(returnRule)) { return(returnRule); } } } catch (MalformedSchemaRuleException e) { if (!_ignoreMalformed) { throw new Exception(e); } } } } return(null); }
public Loaders(RecordStore <NodeRecord> nodeStore, PropertyStore propertyStore, RecordStore <RelationshipRecord> relationshipStore, RecordStore <RelationshipGroupRecord> relationshipGroupStore, RecordStore <PropertyKeyTokenRecord> propertyKeyTokenStore, RecordStore <RelationshipTypeTokenRecord> relationshipTypeTokenStore, RecordStore <LabelTokenRecord> labelTokenStore, SchemaStore schemaStore) { _nodeLoader = _nodeLoader(nodeStore); _propertyLoader = _propertyLoader(propertyStore); _relationshipLoader = _relationshipLoader(relationshipStore); _relationshipGroupLoader = _relationshipGroupLoader(relationshipGroupStore); _schemaRuleLoader = _schemaRuleLoader(schemaStore); _propertyKeyTokenLoader = _propertyKeyTokenLoader(propertyKeyTokenStore); _labelTokenLoader = _labelTokenLoader(labelTokenStore); _relationshipTypeTokenLoader = _relationshipTypeTokenLoader(relationshipTypeTokenStore); }
public RecordAccess_LoaderAnonymousInnerClass5(SchemaStore store) { this._store = store; }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: public static org.neo4j.kernel.impl.transaction.state.RecordAccess_Loader<org.neo4j.kernel.impl.store.record.SchemaRecord,org.neo4j.storageengine.api.schema.SchemaRule> schemaRuleLoader(final org.neo4j.kernel.impl.store.SchemaStore store) public static RecordAccess_Loader <SchemaRecord, SchemaRule> SchemaRuleLoader(SchemaStore store) { return(new RecordAccess_LoaderAnonymousInnerClass5(store)); }
public override bool VisitSchemaRuleCommand(Command.SchemaRuleCommand command) { SchemaStore schemaStore = _neoStores.SchemaStore; if (_version == CommandVersion.BEFORE) { // We are doing reverse-recovery. There is no need for updating the cache, since the indexing service be told what it needs to know when we do // forward-recovery later. bool create = command.Mode == Command.Mode.Create; foreach (DynamicRecord record in command.RecordsBefore) { if (create) { // Schema create commands do not properly store their before images, so we need to correct them. // That is, if the schema was created by this command, then obviously the before image of those records were not in use. record.InUse = false; } schemaStore.UpdateRecord(record); } return(false); } // schema rules. Execute these after generating the property updates so. If executed // before and we've got a transaction that sets properties/labels as well as creating an index // we might end up with this corner-case: // 1) index rule created and index population job started // 2) index population job processes some nodes, but doesn't complete // 3) we gather up property updates and send those to the indexes. The newly created population // job might get those as updates // 4) the population job will apply those updates as added properties, and might end up with duplicate // entries for the same property foreach (DynamicRecord record in command.RecordsAfter) { schemaStore.UpdateRecord(record); } if (command.SchemaRule is ConstraintRule) { switch (command.Mode) { case UPDATE: case CREATE: _neoStores.MetaDataStore.LatestConstraintIntroducingTx = _transactionId; break; case DELETE: break; default: throw new System.InvalidOperationException(command.Mode.name()); } } switch (command.Mode) { case DELETE: _cacheAccess.removeSchemaRuleFromCache(command.Key); break; default: _cacheAccess.addSchemaRule(command.SchemaRule); break; } return(false); }
public DirectRecordAccessSet(RecordStore <NodeRecord> nodeStore, PropertyStore propertyStore, RecordStore <RelationshipRecord> relationshipStore, RecordStore <RelationshipGroupRecord> relationshipGroupStore, RecordStore <PropertyKeyTokenRecord> propertyKeyTokenStore, RecordStore <RelationshipTypeTokenRecord> relationshipTypeTokenStore, RecordStore <LabelTokenRecord> labelTokenStore, SchemaStore schemaStore) { Loaders loaders = new Loaders(nodeStore, propertyStore, relationshipStore, relationshipGroupStore, propertyKeyTokenStore, relationshipTypeTokenStore, labelTokenStore, schemaStore); _nodeRecords = new DirectRecordAccess <NodeRecord, Void>(nodeStore, loaders.NodeLoader()); _propertyRecords = new DirectRecordAccess <PropertyRecord, PrimitiveRecord>(propertyStore, loaders.PropertyLoader()); _relationshipRecords = new DirectRecordAccess <RelationshipRecord, Void>(relationshipStore, loaders.RelationshipLoader()); _relationshipGroupRecords = new DirectRecordAccess <RelationshipGroupRecord, int>(relationshipGroupStore, loaders.RelationshipGroupLoader()); _propertyKeyTokenRecords = new DirectRecordAccess <PropertyKeyTokenRecord, Void>(propertyKeyTokenStore, loaders.PropertyKeyTokenLoader()); _relationshipTypeTokenRecords = new DirectRecordAccess <RelationshipTypeTokenRecord, Void>(relationshipTypeTokenStore, loaders.RelationshipTypeTokenLoader()); _labelTokenRecords = new DirectRecordAccess <LabelTokenRecord, Void>(labelTokenStore, loaders.LabelTokenLoader()); _all = new DirectRecordAccess[] { _nodeRecords, _propertyRecords, _relationshipRecords, _relationshipGroupRecords, _propertyKeyTokenRecords, _relationshipTypeTokenRecords, _labelTokenRecords }; }