private NeoStores resolveNeoStores() { DependencyResolver resolver = db.getDependencyResolver(); RecordStorageEngine storageEngine = resolver.resolveDependency( RecordStorageEngine.class ); return storageEngine.testAccessNeoStores(); }
Worker( int id, AtomicBoolean end, RecordStorageEngine storageEngine, int batchSize, IndexProxy index ) { this.id = id; this.end = end; this.storageEngine = storageEngine; this.batchSize = batchSize; this.index = index; NeoStores neoStores = this.storageEngine.testAccessNeoStores(); this.nodeIds = neoStores.getNodeStore(); this.commandCreationContext = storageEngine.allocateCommandCreationContext(); }
@Override protected BatchTransactionApplierFacade applier( TransactionApplicationMode mode, IndexActivator indexActivator ) { BatchTransactionApplierFacade recordEngineApplier = super.applier( mode, indexActivator ); return transactionApplierTransformer.apply( recordEngineApplier ); } }
private StorageEngine buildStorageEngine( ExplicitIndexProvider explicitIndexProviderLookup, IndexConfigStore indexConfigStore, SchemaState schemaState, SynchronizedArrayIdOrderingQueue explicitIndexTransactionOrdering, OperationalMode operationalMode, VersionContextSupplier versionContextSupplier ) { RecordStorageEngine storageEngine = new RecordStorageEngine( databaseLayout, config, pageCache, fs, logProvider, userLogProvider, tokenHolders, schemaState, constraintSemantics, scheduler, tokenNameLookup, lockService, indexProviderMap, indexingServiceMonitor, databaseHealth, explicitIndexProviderLookup, indexConfigStore, explicitIndexTransactionOrdering, idGeneratorFactory, idController, monitors, recoveryCleanupWorkCollector, operationalMode, versionContextSupplier ); // We pretend that the storage engine abstract hides all details within it. Whereas that's mostly // true it's not entirely true for the time being. As long as we need this call below, which // makes available one or more internal things to the outside world, there are leaks to plug. storageEngine.satisfyDependencies( dataSourceDependencies ); return life.add( storageEngine ); }
@Test public void rotationShouldNotCauseUnmappedFileProblem() throws IOException { // GIVEN GraphDatabaseAPI db = (GraphDatabaseAPI) dbBuilder.newGraphDatabase(); DependencyResolver resolver = db.getDependencyResolver(); RecordStorageEngine storageEngine = resolver.resolveDependency( RecordStorageEngine.class ); CountsTracker countStore = storageEngine.testAccessNeoStores().getCounts(); AtomicBoolean workerContinueFlag = new AtomicBoolean( true ); AtomicLong lookupsCounter = new AtomicLong(); int rotations = 100; for ( int i = 0; i < 5; i++ ) { threadingRule.execute( countStoreLookup( workerContinueFlag, lookupsCounter ), countStore ); } long startTxId = countStore.txId(); for ( int i = 1; (i < rotations) || (lookupsCounter.get() == 0); i++ ) { try ( Transaction tx = db.beginTx() ) { db.createNode( B ); tx.success(); } checkPoint( db ); } workerContinueFlag.set( false ); assertEquals( "Should perform at least 100 rotations.", rotations, Math.min( rotations, countStore.txId() - startTxId) ); assertTrue( "Should perform more then 0 lookups without exceptions.", lookupsCounter.get() > 0 ); db.shutdown(); }
@Test public void shouldDropUniquenessConstraintWithBackingIndexNotInUse() { // given try ( Transaction tx = db.beginTx() ) { db.schema().constraintFor( label ).assertPropertyIsUnique( key ).create(); tx.success(); } // when intentionally breaking the schema by setting the backing index rule to unused RecordStorageEngine storageEngine = db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ); SchemaStore schemaStore = storageEngine.testAccessNeoStores().getSchemaStore(); SchemaRule indexRule = single( filter( rule -> rule instanceof StoreIndexDescriptor, schemaStore.loadAllSchemaRules() ) ); setSchemaRecordNotInUse( schemaStore, indexRule.getId() ); // At this point the SchemaCache doesn't know about this change so we have to reload it storageEngine.loadSchemaCache(); try ( Transaction tx = db.beginTx() ) { single( db.schema().getConstraints( label ).iterator() ).drop(); tx.success(); } // then try ( Transaction ignore = db.beginTx() ) { assertFalse( db.schema().getConstraints().iterator().hasNext() ); assertFalse( db.schema().getIndexes().iterator().hasNext() ); } }
@Test void skipMigrationIfFormatSpecifiedInConfig() { GraphDatabaseService database = startDatabaseWithFormatUnspecifiedUpgrade( storeDir, StandardV3_2.NAME ); try ( Transaction transaction = database.beginTx() ) { Node node = database.createNode(); node.setProperty( "a", "b" ); transaction.success(); } database.shutdown(); GraphDatabaseAPI nonUpgradedStore = (GraphDatabaseAPI) startDatabaseWithFormatUnspecifiedUpgrade( storeDir, StandardV3_2.NAME ); RecordStorageEngine storageEngine = nonUpgradedStore.getDependencyResolver().resolveDependency( RecordStorageEngine.class ); assertEquals( StandardV3_2.NAME, storageEngine.testAccessNeoStores().getRecordFormats().name() ); nonUpgradedStore.shutdown(); }
try ( Transaction tx = db.beginTx() ) Node node1 = set( db.createNode() ); Node node2 = set( db.createNode(), property( "key", "value" ) ); node1.createRelationshipTo( node2, relationshipType ); node1.createRelationshipTo( node2, relationshipType ); node1.createRelationshipTo( node2, relationshipType ); node1.createRelationshipTo( node2, relationshipType ); tx.success(); RecordStorageEngine recordStorageEngine = db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ); NeoStores neoStores = recordStorageEngine.testAccessNeoStores(); RelationshipStore relationshipStore = neoStores.getRelationshipStore(); RelationshipRecord relationshipRecord = new RelationshipRecord( -1 ); RelationshipRecord record = relationshipStore.getRecord( 4, relationshipRecord, RecordLoad.FORCE );
rel5 = db.createNode().createRelationshipTo( node, MyRelTypes.TEST ); rel6 = node.createRelationshipTo( node, MyRelTypes.TEST ); tx.success(); NeoStores neoStores = db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ).testAccessNeoStores(); NodeStore nodeStore = neoStores.getNodeStore(); NodeRecord nodeRecord = getRecord( nodeStore, node.getId() ); long group = nodeRecord.getNextRel(); RecordStore<RelationshipGroupRecord> groupStore = neoStores.getRelationshipGroupStore(); RelationshipGroupRecord groupRecord = getRecord( groupStore, group ); assertEquals( -1, groupRecord.getNext() ); assertEquals( -1, groupRecord.getPrev() ); assertRelationshipChain( neoStores.getRelationshipStore(), node, groupRecord.getFirstOut(), rel1.getId(), rel4.getId() ); assertRelationshipChain( neoStores.getRelationshipStore(), node, groupRecord.getFirstIn(), rel2.getId(), rel5.getId() ); assertRelationshipChain( neoStores.getRelationshipStore(), node, groupRecord.getFirstLoop(), rel3.getId(), rel6.getId() );
@Override public void indexPopulationScanComplete() { monitorCalled.set( true ); db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ).testAccessNeoStores() .getSchemaStore().flush(); storeInNeedOfRecovery[0] = fs.snapshot(); } } );
NeoStores neoStores = ((GraphDatabaseAPI)db).getDependencyResolver().resolveDependency( RecordStorageEngine.class ).testAccessNeoStores(); Function<String, Integer> labelTranslationTable = translationTable( neoStores.getLabelTokenStore(), StatementConstants.ANY_LABEL ); for ( Pair<Integer,Long> count : allNodeCounts( labelTranslationTable, expectedNodeCounts ) ) neoStores.getCounts() .nodeCount( count.first(), newDoubleLongRegister() ) .readSecond() ); translationTable( neoStores.getRelationshipTypeTokenStore(), StatementConstants.ANY_RELATIONSHIP_TYPE ); for ( Pair<RelationshipCountKey,Long> count : allRelationshipCounts( labelTranslationTable, relationshipTypeTranslationTable, expectedRelationshipCounts ) ) tx.success();
@Test public void verifyGroupIsDeletedWhenNeeded() { // TODO test on a lower level instead newDb( 2 ); Transaction tx = db.beginTx(); Node node = db.createNode(); Relationship rel1 = node.createRelationshipTo( db.createNode(), MyRelTypes.TEST ); Relationship rel2 = node.createRelationshipTo( db.createNode(), MyRelTypes.TEST ); Relationship rel3 = node.createRelationshipTo( db.createNode(), MyRelTypes.TEST ); Relationship rel4 = node.createRelationshipTo( db.createNode(), MyRelTypes.TEST2 ); Relationship rel5 = node.createRelationshipTo( db.createNode(), MyRelTypes.TEST2 ); Relationship rel6 = node.createRelationshipTo( db.createNode(), MyRelTypes.TEST2 ); tx.success(); tx.close(); NeoStores neoStores = db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ).testAccessNeoStores(); NodeStore nodeStore = neoStores.getNodeStore(); NodeRecord nodeRecord = getRecord( nodeStore, node.getId() ); long group = nodeRecord.getNextRel(); RecordStore<RelationshipGroupRecord> groupStore = neoStores.getRelationshipGroupStore(); RelationshipGroupRecord groupRecord = getRecord( groupStore, group ); assertNotEquals( groupRecord.getNext(), -1 ); RelationshipGroupRecord otherGroupRecord = groupStore.getRecord( groupRecord.getNext(), groupStore.newRecord(), NORMAL ); assertEquals( -1, otherGroupRecord.getNext() ); // TODO Delete all relationships of one type and see to that the correct group is deleted. }
protected PropertyStore propertyStore() { return graphDb.getDependencyResolver().resolveDependency( RecordStorageEngine.class ) .testAccessNeoStores().getPropertyStore(); } }
private long nextId(GraphDatabaseService database) { long highestId = ((GraphDatabaseAPI) database).getDependencyResolver().resolveDependency(RecordStorageEngine.class).testAccessNeoStores().getNodeStore().getHighestPossibleIdInUse(); long nextId = lastId.incrementAndGet(); if (nextId > highestId) { lastId.set(-1); nextId = lastId.incrementAndGet(); } return nextId; } }
private CountsTracker getTracker() { return ((GraphDatabaseAPI) db).getDependencyResolver().resolveDependency( RecordStorageEngine.class ) .testAccessNeoStores().getCounts(); }
private void flushNeoStoreOnly() { NeoStores neoStores = ((GraphDatabaseAPI) db).getDependencyResolver() .resolveDependency( RecordStorageEngine.class ).testAccessNeoStores(); MetaDataStore metaDataStore = neoStores.getMetaDataStore(); metaDataStore.flush(); }
private void shiftHighId( GraphDatabaseAPI db ) { RecordStorageEngine storageEngine = db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ); NeoStores neoStores = storageEngine.testAccessNeoStores(); neoStores.getRelationshipTypeTokenStore().setHighId( Short.MAX_VALUE - RELATIONSHIP_COUNT / 2 ); }
private static Map<IdType,Long> getHighIds( GraphDatabaseAPI db ) { final Map<IdType,Long> highIds = new HashMap<>(); NeoStores neoStores = db.getDependencyResolver().resolveDependency( RecordStorageEngine.class ).testAccessNeoStores(); Visitor<CommonAbstractStore,RuntimeException> visitor = store -> { highIds.put( store.getIdType(), store.getHighId() ); return true; }; neoStores.visitStore( visitor ); return highIds; }
@BeforeClass public static void initStorage() throws Exception { try ( Transaction transaction = db.beginTx() ) { TokenWrite tokenWrite = getTransaction().tokenWrite(); tokenWrite.propertyKeyGetOrCreateForName( PROP1 ); tokenWrite.propertyKeyGetOrCreateForName( PROP2 ); tokenWrite.labelGetOrCreateForName( LABEL1 ); tokenWrite.labelGetOrCreateForName( LABEL2 ); tokenWrite.relationshipTypeGetOrCreateForName( TYPE1 ); transaction.success(); } SchemaStore schemaStore = resolveDependency( RecordStorageEngine.class ).testAccessNeoStores().getSchemaStore(); storage = new SchemaStorage( schemaStore ); }
tx.success(); workers.awaitAndThrowOnError(); NeoStores neoStores = getDependency( RecordStorageEngine.class ).testAccessNeoStores(); assertThat( "Count store should be rotated once at least", neoStores.getCounts().txId(), greaterThan( 0L ) ); txIdStore.getLastClosedTransactionId(), lastRotationTx ); assertEquals( "Last closed transaction should be last rotated tx in count store", txIdStore.getLastClosedTransactionId(), neoStores.getCounts().txId() );