Examples with ConsistencyCheckService org.neo4j.consistency.ConsistencyCheckService used on opensource projects

Example 6 with ConsistencyCheckService

use of org.neo4j.consistency.ConsistencyCheckService in project neo4j by neo4j.

the class StoreMigrationIT method shouldMigrate.

@Test
public void shouldMigrate() throws Exception {
    File db = testDir.directory(baseDirName(to, from));
    FileSystemAbstraction fs = fileSystemRule.get();
    fs.deleteRecursively(db);
    GraphDatabaseService database = getGraphDatabaseService(db, from.storeVersion());
    database.execute("CREATE INDEX ON :Person(name)");
    database.execute("CREATE INDEX ON :Person(born)");
    database.execute("CREATE CONSTRAINT ON (person:Person) ASSERT exists(person.name)");
    database.execute(CREATE_QUERY);
    long beforeNodes;
    long beforeLabels;
    long beforeKeys;
    long beforeRels;
    long beforeRelTypes;
    long beforeIndexes;
    long beforeConstraints;
    try (Transaction ignore = database.beginTx()) {
        beforeNodes = database.getAllNodes().stream().count();
        beforeLabels = database.getAllLabels().stream().count();
        beforeKeys = database.getAllPropertyKeys().stream().count();
        beforeRels = database.getAllRelationships().stream().count();
        beforeRelTypes = database.getAllRelationshipTypes().stream().count();
        beforeIndexes = stream(database.schema().getIndexes()).count();
        beforeConstraints = stream(database.schema().getConstraints()).count();
    }
    database.shutdown();
    database = getGraphDatabaseService(db, to.storeVersion());
    long afterNodes;
    long afterLabels;
    long afterKeys;
    long afterRels;
    long afterRelTypes;
    long afterIndexes;
    long afterConstraints;
    try (Transaction ignore = database.beginTx()) {
        afterNodes = database.getAllNodes().stream().count();
        afterLabels = database.getAllLabels().stream().count();
        afterKeys = database.getAllPropertyKeys().stream().count();
        afterRels = database.getAllRelationships().stream().count();
        afterRelTypes = database.getAllRelationshipTypes().stream().count();
        afterIndexes = stream(database.schema().getIndexes()).count();
        afterConstraints = stream(database.schema().getConstraints()).count();
    }
    database.shutdown();
    //171
    assertEquals(beforeNodes, afterNodes);
    //2
    assertEquals(beforeLabels, afterLabels);
    //8
    assertEquals(beforeKeys, afterKeys);
    //253
    assertEquals(beforeRels, afterRels);
    //6
    assertEquals(beforeRelTypes, afterRelTypes);
    //2
    assertEquals(beforeIndexes, afterIndexes);
    //1
    assertEquals(beforeConstraints, afterConstraints);
    ConsistencyCheckService consistencyCheckService = new ConsistencyCheckService();
    ConsistencyCheckService.Result result = runConsistencyChecker(db, fs, consistencyCheckService, to.storeVersion());
    if (!result.isSuccessful()) {
        fail("Database is inconsistent after migration.");
    }
}

Example 7 with ConsistencyCheckService

use of org.neo4j.consistency.ConsistencyCheckService in project neo4j by neo4j.

the class StoreMigratorFrom21IT method mustMendDuplicatePropertiesWhenUpgradingFromVersion21.

@Test
public void mustMendDuplicatePropertiesWhenUpgradingFromVersion21() throws Exception {
    // The rules:
    // If an index is present, all duplicates should be removed and the property set to the value in the index
    // If an index is not present, the property should be set to the value of the last duplicate in the property
    // chain, all duplicates except the first should be removed
    // If an index is not present, the first property in the duplicate chain should be kept for the users
    // benefit, moved to a special property value, `__DUPLICATE_<propkey>`
    //
    // This is the broken store that we are upgrading:
    //
    //   (#0:Label { keyA: "actual", keyA: "phony!", keyA: "phony!" })
    //   (#1 { keyA: "actual", keyA: "actual", keyA: "actual" })
    //   (#2:Label { keyA: "real1", keyA: "phony", keyA: "phony", keyD: "real2", keyD: "phony", keyD: "phony" })
    //   (#3 { keyA: "real1", keyA: "phony", keyA: "phony", keyD: "real2", keyD: "phony", keyD: "phony" })
    //   (#4 { keyA: "actual", keyB: "actual", keyC: "actual" })
    //   (#0)-[#0:REL { keyA: "actual", keyA: "actual", keyA: "actual" }]->(#1)
    //   (#0)-[#1:REL { keyA: "real1", keyA: "phony", keyA: "phony",
    //                  keyD: "real2", keyE: "phony", keyF: "phony" }]->(#1)
    //   (#2)-[#2:REL { keyA: "actual", keyB: "actual", keyC: "actual" }]->(#0)
    //
    // And this is what we want to end up with, after upgrading:
    //
    //   (#0:Label { keyA: "actual" })
    //   (#1 { keyA: "actual", __DUPLICATE_keyA: "actual" })
    //   (#2:Label { keyA: "real1", keyD: "real2" })
    //   (#3 { keyA: "real1", __DUPLICATE_keyA_1: "real1", __DUPLICATE_keyA_2: "real1",
    //         keyD: "real2", __DUPLICATE_keyD_1: "real2", __DUPLICATE_keyD_2: "real2" })
    //   (#4 { keyA: "actual", keyB: "actual", keyC: "actual" })
    //   (#0)-[#0:REL { keyA: "actual", __DUPLICATE_keyA: "actual" }]->(#1)
    //   (#0)-[#1:REL { keyA: "real1", __DUPLICATE_keyA_1: "real1", __DUPLICATE_keyA_2: "real1",
    //                  keyD: "real2", __DUPLICATE_keyD_1: "real2", __DUPLICATE_keyD_2: "real2" }]->(#1)
    //   (#2)-[#2:REL { keyA: "actual", keyB: "actual", keyC: "actual" }]->(#0)
    File dir = MigrationTestUtils.find21FormatStoreDirectoryWithDuplicateProperties(storeDir.directory());
    TestGraphDatabaseFactory factory = new TestGraphDatabaseFactory();
    GraphDatabaseBuilder builder = factory.newEmbeddedDatabaseBuilder(dir).setConfig(GraphDatabaseSettings.allow_store_upgrade, "true");
    GraphDatabaseService database = builder.newGraphDatabase();
    database.shutdown();
    ConsistencyCheckService service = new ConsistencyCheckService();
    ConsistencyCheckService.Result result = service.runFullConsistencyCheck(dir.getAbsoluteFile(), Config.empty(), ProgressMonitorFactory.NONE, NullLogProvider.getInstance(), false);
    assertTrue(result.isSuccessful());
    database = builder.newGraphDatabase();
    // Upgrade is now completed. Verify the contents:
    DependencyResolver dependencyResolver = ((GraphDatabaseAPI) database).getDependencyResolver();
    // Verify that the properties appear correct to the outside world:
    try (Transaction ignore = database.beginTx()) {
        verifyProperties(database.getNodeById(0), Pair.of("keyA", new Object[] { "actual", "phony!", "phony!" }));
        verifyProperties(database.getNodeById(1), Pair.of("keyA", new Object[] { "actual", "actual", "actual" }));
        verifyProperties(database.getNodeById(2), Pair.of("keyA", new Object[] { "real1", "phony", "phony" }), Pair.of("keyD", new Object[] { "real2", "phony", "phony" }));
        verifyProperties(database.getNodeById(3), Pair.of("keyA", new Object[] { "real1", "real1", "real1" }), Pair.of("keyD", new Object[] { "real2", "real2", "real2" }));
        verifyProperties(database.getNodeById(4), Pair.of("keyA", new Object[] { "actual" }), Pair.of("keyB", new Object[] { "actual" }), Pair.of("keyC", new Object[] { "actual" }));
        verifyProperties(database.getRelationshipById(0), Pair.of("keyA", new Object[] { "actual", "actual", "actual" }));
        verifyProperties(database.getRelationshipById(1), Pair.of("keyA", new Object[] { "real1", "real1", "real1" }), Pair.of("keyD", new Object[] { "real2", "real2", "real2" }));
        verifyProperties(database.getRelationshipById(2), Pair.of("keyA", new Object[] { "actual" }), Pair.of("keyB", new Object[] { "actual" }), Pair.of("keyC", new Object[] { "actual" }));
    }
    // Verify that there are no two properties on the entities, that have the same key:
    // (This is important because the verification above cannot tell if we have two keys with the same value)
    KernelAPI kernel = dependencyResolver.resolveDependency(KernelAPI.class);
    try (KernelTransaction tx = kernel.newTransaction(KernelTransaction.Type.implicit, AnonymousContext.read());
        Statement statement = tx.acquireStatement()) {
        Iterators.asUniqueSet(statement.readOperations().nodeGetPropertyKeys(0));
        Iterators.asUniqueSet(statement.readOperations().nodeGetPropertyKeys(1));
        Iterators.asUniqueSet(statement.readOperations().nodeGetPropertyKeys(2));
        Iterators.asUniqueSet(statement.readOperations().relationshipGetPropertyKeys(0));
        Iterators.asUniqueSet(statement.readOperations().relationshipGetPropertyKeys(1));
    }
    database.shutdown();
}

Example 8 with ConsistencyCheckService

use of org.neo4j.consistency.ConsistencyCheckService in project neo4j by neo4j.

the class MultipleIndexPopulationStressIT method runTest.

private void runTest(int nodeCount, int run, boolean multiThreaded) throws Exception {
    // WHEN creating the indexes under stressful updates
    populateDbAndIndexes(nodeCount, multiThreaded);
    ConsistencyCheckService cc = new ConsistencyCheckService();
    Result result = cc.runFullConsistencyCheck(directory.graphDbDir(), Config.embeddedDefaults(stringMap(GraphDatabaseSettings.pagecache_memory.name(), "8m")), NONE, NullLogProvider.getInstance(), false);
    assertTrue(result.isSuccessful());
    dropIndexes();
}

Example 9 with ConsistencyCheckService

use of org.neo4j.consistency.ConsistencyCheckService in project neo4j by neo4j.

the class ConcurrentChangesOnEntitiesTest method assertDatabaseConsistent.

private void assertDatabaseConsistent() throws IOException {
    LogProvider logProvider = FormattedLogProvider.toOutputStream(System.out);
    try {
        ConsistencyCheckService.Result result = new ConsistencyCheckService().runFullConsistencyCheck(testDirectory.graphDbDir(), Config.defaults(), ProgressMonitorFactory.textual(System.err), logProvider, false);
        assertTrue(result.isSuccessful());
    } catch (ConsistencyCheckIncompleteException e) {
        fail(e.getMessage());
    }
}