Nitrite Java Documentation

Nitrite allows you to define Migration objects to evolve your database schema. Migrations are applied during database initialization using .addMigrations(...). You must specify a .schemaVersion(int) in the builder for migrations to be active.

Migration migration1 = new Migration(Constants.INITIAL_SCHEMA_VERSION, 2) {
    @Override
    public void migrate(InstructionSet instructions) {
        instructions.forDatabase()
            .addUser("test-user", "test-password");

        instructions.forRepository(OldClass.class, "demo1")
            .renameRepository("migrated", null)
            .changeDataType("empId", (TypeConverter<String, Long>) Long::parseLong)
            .changeIdField(Fields.withNames("uuid"), Fields.withNames("empId"))
            .deleteField("uuid")
            .renameField("lastName", "familyName")
            .addField("fullName", document -> document.get("firstName", String.class) + " "
                + document.get("familyName", String.class))
            .dropIndex("firstName")
            .dropIndex("literature.text")
            .changeDataType("literature.ratings", (TypeConverter<Float, Integer>) Math::round);
    }
};

// ... (migration2 definition)

// Applying migrations during initialization
db = Nitrite.builder()
    .loadModule(storeModule)
    .schemaVersion(2)
    .addMigrations(migration1, migration2)
    .openOrCreate();

Use the Exporter class to save your Nitrite database contents to a JSON file. You must provide ExportOptions which include a NitriteFactory to initialize the database instance, and specify which collections, repositories, or keyed repositories should be included in the export.

Key configuration methods for ExportOptions:

• setNitriteFactory(Supplier<Nitrite>): Provides the logic to open/create the database instance.
• setCollections(List<String>): Specifies the names of the collections to export.
• setRepositories(List<String>): Specifies the class names of the repositories to export.
• setKeyedRepositories(Map<String, Set<String>>): Specifies keyed repositories mapping a key to a set of class names.

// export data to a json file
ExportOptions exportOptions = new ExportOptions();
exportOptions.setNitriteFactory(() -> {
    MVStoreModule storeModule = MVStoreModule.withConfig()
        .filePath("/tmp/test-old.db")
        .build();
    
    return Nitrite.builder()
        .compressed()
        .loadModule(storeModule)
        .openOrCreate();
});
exportOptions.setCollections(List.of("first"));
exportOptions.setRepositories(List.of("org.dizitart.no2.support.data.Employee"));
exportOptions.setKeyedRepositories(Map.of("key", Set.of("org.dizitart.no2.support.data.Employee")));

Exporter exporter = Exporter.withOptions(exportOptions);
exporter.exportTo(schemaFile);

To use Nitrite in a Java application, use the Nitrite Bill of Materials (BOM) to manage versions, then add the core nitrite dependency and your preferred storage adapter (e.g., nitrite-mvstore-adapter).

### Maven

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.dizitart</groupId>
            <artifactId>nitrite-bom</artifactId>
            <version>[latest version]</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.dizitart</groupId>
        <artifactId>nitrite</artifactId>
    </dependency>

    <dependency>
        <groupId>org.dizitart</groupId>
        <artifactId>nitrite-mvstore-adapter</artifactId>
    </dependency>
</dependencies>

### Gradle

```groovy

implementation(platform("org.dizitart:nitrite-bom:[latest version]"))
    
implementation 'org.dizitart:nitrite'
implementation 'org.dizitart:nitrite-mvstore-adapter'

Nitrite Spatial provides three types of spatial filters for querying documents based on geometry:

• Intersect Filter: Matches documents where the field's spatial data intersects the specified Geometry.
• Within Filter: Matches documents where the field's spatial data is contained within the specified Geometry.
• Near Filter: Matches documents where the field's spatial data is near a specific coordinate within a given distance.

Note: These examples use WKTReader from the JTS library to parse Well-Known Text (WKT) into Geometry objects.

// Intersect
WKTReader reader = new WKTReader();
Geometry search = reader.read("POLYGON ((490 490, 536 490, 536 515, 490 515, 490 490))");
Cursor<SpatialData> cursor = repository.find(where("geometry").intersects(search));

// Within
Geometry searchWithin = reader.read("POLYGON ((490 490, 536 490, 536 515, 490 515, 490 490))");
Cursor<SpatialData> cursorWithin = repository.find(where("geometry").within(searchWithin));

// Near
Point searchPoint = (Point) reader.read("POINT (490 490)");
Cursor<SpatialData> cursorNear = repository.find(where("geometry").near(searchPoint, 20.0));