Nitrite

Nitrite db = Nitrite.builder()
        .filePath("/tmp/test.db")
        .openOrCreate("username", "password");

// Employee class
@Indices({
        @Index(value = "joinDate", type = IndexType.NonUnique),
        @Index(value = "name", type = IndexType.Unique)
})
public class Employee implements Serializable {
    @Id
    private long empId;

    private Date joinDate;

    private String name;

    private String address;

    // ... public getters and setters
}

Nitrite db = Nitrite.builder()
            .nitriteMapper(new GSONMapper())        // custom NitriteMapper
            .filePath("/tmp/test.db")
            .openOrCreate("user", "password");

Nitrite db = Nitrite.builder()
            .registerModule(new Jdk8Module())        // register jdk8 module
            .registerModule(new JavaTimeModule())    // register java.time module
            .filePath("/tmp/test.db")
            .openOrCreate("user", "password");

public class Employee implements Mappable {
    private String empId;
    private String name;
    private Date joiningDate;
    private Employee boss;

    @Override
    public Document write(NitriteMapper mapper) {
        Document document = new Document();
        document.put("empId", getEmpId());
        document.put("name", getName());
        document.put("joiningDate", getJoiningDate());

        if (getBoss() != null) {
            Document bossDoc = getBoss().write(mapper);
            document.put("boss", bossDoc);
        }
        return document;
    }

    @Override
    public void read(NitriteMapper mapper, Document document) {
        if (document != null) {
            setEmpId((String) document.get("empId"));
            setName((String) document.get("name"));
            setJoiningDate((Date) document.get("joiningDate"));

            Document bossDoc = (Document) document.get("boss");
            if (bossDoc != null) {
                Employee bossEmp = new Employee();
                bossEmp.read(mapper, bossDoc);
                setBoss(bossEmp);
            }
        }
    }
}

WriteResult result = collection.insert(doc1, doc2, doc3);

System.out.println("Affected counts - " + result.getAffectedCount());

for (NitriteId id : result) {
    System.out.println("Id - " + id);
}

WriteResult insert(Document document, Document... documents)
WriteResult insert(Document[] documents)

WriteResult insert(T object, T... others)
WriteResult insert(T[] objects)

// insert one document
collection.insert(doc1);

// insert multiple documents
collection.insert(doc1, doc2, doc3);

// another way to insert multiple documents
Document[] documents = new Document[] {doc1, doc2, doc3};
collection.insert(documents);


// create employee object
Employee emp1 = new Employee();
emp1.setEmpNumber(12548);
emp1.setEmpName("John Doe");

// insert employee object
repository.insert(emp1);

// insert multiple employee objects
repository.insert(emp1, emp2, emp3);

// another way to insert multiple objects
Employee[] employees = new Employee[] {emp1, emp2, emp3};
repository.insert(employees);

WriteResult update(Document update)
WriteResult update(Document update, boolean upsert)
WriteResult update(Filter filter, Document update)
WriteResult update(Filter filter, Document update, UpdateOptions updateOptions)

WriteResult update(T element)
WriteResult update(T element, boolean upsert)
WriteResult update(ObjectFilter filter, T update)
WriteResult update(ObjectFilter filter, T update, boolean upsert)
WriteResult update(ObjectFilter filter, Document update)
WriteResult update(ObjectFilter filter, Document update, boolean justOnce)

WriteResult update(Document document)
WriteResult update(T object)

Employee emp = new Employee();
emp.setEmpId(12564);
emp.setAddress("12 Some Street");
employeeRepository.insert(emp);

// update object
emp.setAddress("25 New Street");
employeeRepository.update(emp);



Document doc = createDocument("name", "John Doe")
                    .put("age", 30);
NitriteId nitriteId = doc.getId();
collection.insert(doc);

// update the document
Document document = collection.getById(nitriteId);
document.put("age", 31);

collection.update(document);

WriteResult update(Document update, boolean upsert)
WriteResult update(T object, boolean upsert)

emp.setAddress("25 New Street");
// if emp object is not there in repository, it will be inserted
employeeRepository.update(emp, true);


Document document = createDocument("firstName", "John")
                    .put("lastName", "Doe");
// generates NitriteId of the document
document.getId();
// if filter does not find any document, it will insert 'document'
WriteResult updateResult = collection.update(document, true);

WriteResult update(Filter filter, Document update)
WriteResult update(ObjectFilter filter, T update)
WriteResult update(ObjectFilter filter, Document update)

Employee emp = new Employee();
emp.setEmpId(12564);
emp.setAddress("12 Some Street");
emp.setCity("Kolkata");
employeeRepository.insert(emp);

// update all employees' join date whose city = Kolkata
Employee empUpdate = new Employee();
// id field should not be set here
empUpdate.setJoinDate(new Date());

// if emp object is not there in repository, it will not insert
employeeRepository.update(eq("city", "Kolkata"), empUpdate);

WriteResult update(Filter filter, Document update, UpdateOptions updateOptions)
WriteResult update(ObjectFilter filter, T update, boolean upsert)
WriteResult update(ObjectFilter filter, Document update, boolean justOnce)

// simple update example
// update the documents whose firstName = fn1 with lastName = newLastName1
WriteResult updateResult = collection.update(eq("firstName", "fn1"),
                createDocument("lastName", "newLastName1"));


// update with update options
// create an update options
UpdateOptions updateOptions = new UpdateOptions();
updateOptions.setJustOnce(true);    // only first document will be updated
updateOptions.setUpsert(false);     // no upsert

// update the document whose firstName != fn1 with lastName = newLastName1 but no upsert
// and it will update only 1 document
Document document = createDocument("lastName", "newLastName1");
WriteResult updateResult = collection.update(not(eq("firstName", "fn1")),
                document, updateOptions);

WriteResult remove(Document element)
WriteResult remove(Filter filter)
WriteResult remove(Filter filter, RemoveOptions removeOptions)

WriteResult remove(T object)
WriteResult remove(ObjectFilter filter)
WriteResult remove(ObjectFilter filter, RemoveOptions removeOptions)

// removes all documents where firstName = John
collection.remove(eq("firstName", "John"));

// removes all documents
collection.remove(Filters.ALL);

// removes a single document
collection.remove(doc);

// removes all objects where firstName = John
repository.remove(eq("firstName", "John"))

// remove all objects
repository.remove(ObjectFilters.ALL);

RemoveOptions options = new RemoveOptions();
options.setJustOne(true);

// removes first document where firstName = John
collection.remove(eq("firstName", "John"), options);

Cursor find()
Cursor find(FindOptions findOptions)
Cursor find(Filter filter)
Cursor find(Filter filter, FindOptions findOptions)
Document getById(NitriteId nitriteId);

Cursor<T> find()
Cursor<T> find(FindOptions findOptions)
Cursor<T> find(ObjectFilter filter)
Cursor<T> find(ObjectFilter filter, FindOptions findOptions)
T getById(NitriteId nitriteId);

// extracts all records from the collections
Cursor results = collection.find();

// extracts paginated records from the collections
Cursor results = collection.find(FindOptions.limit(0, 1));

// extracts all records and sorts them based on the value of 'age' field
Cursor results = collection.find(FindOptions.sort("age", SortOrder.Ascending));

// extracts all records where value of 'age' field is greater than 30
Cursor results = collection.find(Filters.gt("age", 30));

// finds all records where 'age' field value is greater than 30
// then sorts those records in ascending order and takes first 10 records
Cursor results = collection.find(Filters.gt("age", 30), FindOptions
                                        .sort("age", SortOrder.Ascending)
                                        .thenLimit(0, 10));

// gets a document from the collection corresponding to a NitriteId
Document document = collection.getById(id);

// extracts all objects from the repository
org.dizitart.no2.objects.Cursor<Employee> cursor = repository.find();

// extracts paginated employee records from the repository
Cursor<Employee> cursor = repository.find(limit(0, 1));

// extracts all employee records and sorts them based on the value of 'age' field
Cursor<Employee> cursor = repository.find(sort("age", SortOrder.Ascending));

// extracts all employee records where value of 'age' field is greater than 30
Cursor<Employee> cursor = repository.find(ObjectFilters.gt("age", 30));

// finds all employee records where 'age' field value is greater than 30
// then sorts those records in ascending order and takes first 10 records
Cursor<Employee> cursor = repository.find(ObjectFilters.gt("age", 30),
                                        sort("age", SortOrder.Ascending)
                                        .thenLimit(0, 10));

// gets a employee from the repository corresponding to a NitriteId
Employee employee = repository.getById(id);

Cursor cursor = collection.find();
for (Document document : cursor) {
    //...
}

Cursor<Employee> cursor = repository.find();
for (Employee employee : cursor) {
    //...
}

// sorts all records by age in ascending order then take first 10 records and return as a Cursor
Cursor results = collection.find(sort("age", SortOrder.Ascending).thenLimit(0, 10));

// sorts the records by age in ascending order
Cursor results = collection.find(sort("age", SortOrder.Ascending));

// sorts the records by name in ascending order with custom collator
Cursor results = collection.find(sort("name", SortOrder.Ascending, Collator.getInstance(Locale.FRANCE)));

// fetch 10 records starting from offset = 2
Cursor results = collection.find(limit(2, 10));

// find a document which contains an "info" embedded document with age 30
Document doc = createDocument("firstName", "John")
     .put("lastName", "Doe")
     .put("info", createDocument("age", 30));
collection.insert(doc);

Cursor results = collection.find(Filters.eq("info.age", 30));


// find an employee whose note contains email addresses
@Data
@Indices({
        @Index(value = "employeeNote.text", type = IndexType.Fulltext)
})
public class Employee implements Serializable {
    @Id
    private Long empId;

    private Note employeeNote;
}

@Data
public class Note {
    @Id
    private Long noteId;

    private String text;
}

Cursor<Employee> cursor = employeeRepository.find(regex("employeeNote.text", "^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,6}$"));

Cursor cursor = collection.find(lte("birthDay", new Date()),
                sort("firstName", SortOrder.Ascending).thenLimit(0, 3));

// a document with only selected field - 'firstName' and 'lastName'
Document projection = createDocument("firstName", null)
                .put("lastName", null);
// it will return documents containing only 'firstName' and 'lastName'
RecordIterable<Document> documents = cursor.project(projection);


// it will return Employees containing every field that has been inserted
Cursor<Employee> projection = repository.find();

// it will return list of SubEmployee objects containing only some fields
// of Employee object
List<SubEmployee> subEmployeeList
                = repository.find().project(SubEmployee.class).toList();

Document doc1 = createDocument("firstName", "fn1")
                .put("lastName", "ln1")
                .put("birthDay", simpleDateFormat.parse("2012-07-01T16:02:48.440Z"))
                .put("data", new byte[] {1, 2, 3})
                .put("list", new ArrayList<String>() {{ add("one"); add("two"); add("three"); }})
                .put("body", "a quick brown fox jump over the lazy dog");

Document doc2 = createDocument("firstName", "fn2")
                .put("lastName", "ln2")
                .put("birthDay", simpleDateFormat.parse("2010-06-12T16:02:48.440Z"))
                .put("data", new byte[] {3, 4, 3})
                .put("list", new ArrayList<String>() {{ add("three"); add("four"); add("three"); }})
                .put("body", "quick hello world from nitrite");

Document doc3 = createDocument("firstName", "fn3")
                .put("lastName", "ln2")
                .put("birthDay", simpleDateFormat.parse("2014-04-17T16:02:48.440Z"))
                .put("data", new byte[] {9, 4, 8})
                .put("body", "Lorem ipsum dolor sit amet, consectetur adipiscing elit. " +
                        "Sed nunc mi, mattis ullamcorper dignissim vitae, condimentum non lorem.");

collection.insert(doc1, doc2, doc3);

// another collection

Document fdoc1 = createDocument("fName", "fn1")
                .put("address", "ABCD Street")
                .put("telephone", "123456789");

Document fdoc2 = createDocument("fName", "fn2")
                .put("address", "XYZ Street")
                .put("telephone", "000000000");

Document fdoc3 = createDocument("fName", "fn2")
                .put("address", "Some other Street")
                .put("telephone", "7893141321");

foreignCollection.insert(fdoc1, fdoc2, fdoc3);

// join operation

Lookup lookup = new Lookup();
lookup.setLocalField("firstName");
lookup.setForeignField("fName");
lookup.setTargetField("personalDetails");

RecordIterable<Document> result = collection.find().join(foreignCollection.find(), lookup);

{
    firstName=fn1,
    lastName=ln1,
    birthDay=Sun Jul 01 16:02:48   IST 2012,
    data=   [1, 2, 3],
    list=   [
         one,
         two,
         three
    ],
    body="a quick brown fox jump over the lazy dog",
    _id=9078368118890,
    _revision=1,
    _modified=1510638278124,
    personalDetails=      [
         {
            fName=fn1,
            address=ABCD Street,
            telephone=123456789,
            _id=9078368118887,
            _revision=1,
            _modified=1510638278119
         }
    ]
}

{
    firstName=fn2,
    lastName=ln2,
    birthDay=Sat Jun 12 16:02:48   IST 2010,
    data=   [3, 4, 3],
    list=   [
         three,
         four,
         three
    ],
    body="quick hello world from nitrite",
    _id=9078368118891,
    _revision=1,
    _modified=1510638278130,
    personalDetails=      [
         {
            fName=fn2,
            address=XYZ Street,
            telephone=000000000,
            _id=9078368118888,
            _revision=1,
            _modified=1510638278123
         },
         {
            fName=fn2,
            address=Some other Street,
            telephone=7893141321,
            _id=9078368118889,
            _revision=1,
            _modified=1510638278123
         }
    ]
}

{
    firstName=fn3,
    lastName=ln2,
    birthDay=Thu Apr 17 16:02:48   IST 2014,
    data=   [ 9, 4, 8],
    body="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed nunc mi, mattis ullamcorper dignissim vitae, condimentum non lorem.",
    _id=9078368118892,
    _revision=1,
    _modified=1510638278130
}

import lombok.Data;

@Data
public static class Person {
    private String id;
    private String name;
}

@Data
public static class Address {
    private String personId;
    private String street;
}

@Data
public static class PersonDetails {
    private String id;
    private String name;
    private List<Address> addresses;
}

Lookup lookup = new Lookup();
lookup.setLocalField("id");
lookup.setForeignField("personId");
lookup.setTargetField("addresses");

RecordIterable<PersonDetails> result
        = personRepository.find().join(addressRepository.find(), lookup,
        PersonDetails.class);

collection.createIndex("notes", indexOptions(IndexType.Fulltext, true));

UniversalTextTokenizer tokenizer = new UniversalTextTokenizer();
// enable tokenizer for bengali, english and chinese text only
tokenizer.loadLanguage(Languages.Bengali, Languages.English, Languages.Chinese);

// or, enable tokenization for all supported languages (resource heavy, as it loads all stop words in memory)
tokenizer.loadAllLanguages();

// initialize db with the universal tokenizer
Nitrite db = Nitrite.builder()
            .textTokenizer(tokenizer)
            .filePath("/tmp/test.db")
            .openOrCreate();

/*
 *
 * Copyright 2017-2018 Nitrite author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package org.dizitart.no2.services;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.*;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.dizitart.no2.NitriteId;
import org.dizitart.no2.exceptions.IndexingException;
import org.dizitart.no2.fulltext.TextIndexingService;

import java.io.IOException;
import java.util.LinkedHashSet;
import java.util.Set;

import static org.dizitart.no2.exceptions.ErrorMessage.errorMessage;
import static org.dizitart.no2.util.StringUtils.isNullOrEmpty;

public class LuceneService implements TextIndexingService {
    private static final String CONTENT_ID = "content_id";
    private static final int MAX_SEARCH = Byte.MAX_VALUE;

    private IndexWriter indexWriter;
    private ObjectMapper keySerializer;
    private Analyzer analyzer;
    private Directory indexDirectory;

    public LuceneService() {
        try {
            this.keySerializer = new ObjectMapper();
            keySerializer.setVisibility(keySerializer
                .getSerializationConfig()
                .getDefaultVisibilityChecker()
                .withFieldVisibility(JsonAutoDetect.Visibility.ANY)
                .withGetterVisibility(JsonAutoDetect.Visibility.NONE)
                .withIsGetterVisibility(JsonAutoDetect.Visibility.NONE));

            indexDirectory = new RAMDirectory();
            analyzer = new StandardAnalyzer();

            IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
            iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
            indexWriter = new IndexWriter(indexDirectory, iwc);
        } catch (IOException e) {
            throw new IndexingException(errorMessage("could not create full-text index", 0), e);
        } catch (VirtualMachineError vme) {
            handleVirtualMachineError(vme);
        }
    }

    @Override
    public void createIndex(NitriteId id, String field, String text) {
        try {
            Document document = new Document();
            String jsonId = keySerializer.writeValueAsString(id);
            Field contentField = new TextField(field, text, Field.Store.NO);
            Field idField = new StringField(CONTENT_ID, jsonId, Field.Store.YES);

            document.add(idField);
            document.add(contentField);

            synchronized (this) {
                indexWriter.addDocument(document);
            }
        } catch (IOException ioe) {
            throw new IndexingException(errorMessage("could not write full-text index data for " + text, 0), ioe);
        } catch (VirtualMachineError vme) {
            handleVirtualMachineError(vme);
        }
    }

    @Override
    public void updateIndex(NitriteId id, String field, String text) {
        try {
            String jsonId = keySerializer.writeValueAsString(id);
            Document document = getDocument(jsonId);
            if (document == null) {
                document = new Document();
                Field idField = new StringField(CONTENT_ID, jsonId, Field.Store.YES);
                document.add(idField);
            }
            Field contentField = new TextField(field, text, Field.Store.YES);

            document.add(contentField);

            synchronized (this) {
                indexWriter.updateDocument(new Term(CONTENT_ID, jsonId), document);
            }
        } catch (IOException ioe) {
            throw new IndexingException(errorMessage("could not update full-text index for " + text, 0), ioe);
        } catch (VirtualMachineError vme) {
            handleVirtualMachineError(vme);
        }
    }

    @Override
    public void deleteIndex(NitriteId id, String field, String text) {
        try {
            String jsonId = keySerializer.writeValueAsString(id);
            Term idTerm = new Term(CONTENT_ID, jsonId);

            synchronized (this) {
                indexWriter.deleteDocuments(idTerm);
            }
        } catch (IOException ioe) {
            throw new IndexingException(errorMessage("could not remove full-text index for " + id, 0));
        } catch (VirtualMachineError vme) {
            handleVirtualMachineError(vme);
        }
    }

    @Override
    public void deleteIndexesByField(String field) {
        if (!isNullOrEmpty(field)) {
            try {
                Query query;
                QueryParser parser = new QueryParser(field, analyzer);
                parser.setAllowLeadingWildcard(true);
                try {
                    query = parser.parse("*");
                } catch (ParseException e) {
                    throw new IndexingException(errorMessage("could not remove full-text index for value " + field, 0));
                }

                synchronized (this) {
                    indexWriter.deleteDocuments(query);
                }
            } catch (IOException ioe) {
                throw new IndexingException(errorMessage("could not remove full-text index for value " + field, 0));
            } catch (VirtualMachineError vme) {
                handleVirtualMachineError(vme);
            }
        }
    }

    @Override
    public Set<NitriteId> searchByIndex(String field, String searchString) {
        IndexReader indexReader = null;
        try {
            QueryParser parser = new QueryParser(field, analyzer);
            parser.setAllowLeadingWildcard(true);
            Query query = parser.parse("*" + searchString + "*");

            indexReader = DirectoryReader.open(indexDirectory);
            IndexSearcher indexSearcher = new IndexSearcher(indexReader);

            TopScoreDocCollector collector = TopScoreDocCollector.create(MAX_SEARCH);
            indexSearcher.search(query, collector);

            TopDocs hits = collector.topDocs(0, MAX_SEARCH);

            Set<NitriteId> keySet = new LinkedHashSet<>();
            if (hits != null) {
                ScoreDoc[] scoreDocs = hits.scoreDocs;
                if (scoreDocs != null) {
                    for (ScoreDoc scoreDoc : scoreDocs) {
                        Document document = indexSearcher.doc(scoreDoc.doc);
                        String jsonId = document.get(CONTENT_ID);
                        NitriteId nitriteId = keySerializer.readValue(jsonId, NitriteId.class);
                        keySet.add(nitriteId);
                    }
                }
            }

            return keySet;
        } catch (IOException | ParseException e) {
            throw new IndexingException(errorMessage("could not search on full-text index", 0), e);
        } finally {
            try {
                if (indexReader != null)
                    indexReader.close();
            } catch (IOException ignored) {
                // ignored
            }
        }
    }

    private Document getDocument(String jsonId) {
        IndexReader indexReader = null;
        try {
            Term idTerm = new Term(CONTENT_ID, jsonId);

            TermQuery query = new TermQuery(idTerm);

            indexReader = DirectoryReader.open(indexDirectory);
            IndexSearcher indexSearcher = new IndexSearcher(indexReader);

            TopScoreDocCollector collector = TopScoreDocCollector.create(MAX_SEARCH);
            indexSearcher.search(query, collector);

            TopDocs hits = collector.topDocs(0, MAX_SEARCH);
            Document document = null;
            if (hits != null) {
                ScoreDoc[] scoreDocs = hits.scoreDocs;
                if (scoreDocs != null) {
                    for (ScoreDoc scoreDoc : scoreDocs) {
                        document = indexSearcher.doc(scoreDoc.doc);
                    }
                }
            }

            return document;
        } catch (IOException e) {
            throw new IndexingException(errorMessage("could not search on full-text index", 0), e);
        } finally {
            try {
                if (indexReader != null)
                    indexReader.close();
            } catch (IOException ignored) {
                // ignored
            }
        }
    }

    @Override
    public void drop() {
        try {
            indexDirectory = new RAMDirectory();
            analyzer = new StandardAnalyzer();

            IndexWriterConfig iwc = new IndexWriterConfig(analyzer);
            iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
            indexWriter = new IndexWriter(indexDirectory, iwc);
        } catch (IOException e) {
            throw new IndexingException(errorMessage("could not drop full-text index", 0), e);
        }
    }

    @Override
    public void clear() {
        try {
            indexWriter.deleteAll();
        } catch (IOException e) {
            throw new IndexingException(errorMessage("could not clear full-text index", 0), e);
        }
    }

    private void handleVirtualMachineError(VirtualMachineError vme) {
        if (indexWriter != null) {
            try {
                indexWriter.close();
            } catch (IOException ioe) {
                // ignore it
            }
        }
        throw vme;
    }

    @Override
    public void commit() {
        try {
            indexWriter.commit();
        } catch (IOException e) {
            throw new IndexingException(errorMessage("could not commit unsaved changes", 0), e);
        }
    }

    @Override
    public void close() {
        if (indexWriter != null) {
            try {
                commit();
                indexWriter.close();
            } catch (IOException ioe) {
                // ignore it
            }
        }
    }
}

// Configure third-party indexing service while opening the database
Nitrite db = Nitrite.builder()
            .textIndexingService(new LuceneService())
            .filePath("/tmp/test.db")
            .openOrCreate();

import org.dizitart.no2.IndexType;
import org.dizitart.no2.objects.Id;
import org.dizitart.no2.objects.Index;
import org.dizitart.no2.objects.Indices;


@Indices({
        @Index(value = "joinDate", type = IndexType.NonUnique),
        @Index(value = "address", type = IndexType.Fulltext),
        @Index(value = "employeeNote.text", type = IndexType.Fulltext)
})
public class Employee implements Serializable {
    @Id
    private long empId;

    private Date joinDate;

    private String address;

    private Note employeeNote;
}

public class Note {
    @Id
    private long noteId;

    private String text;
}

@Indices(
        @Index(value = "date", type = IndexType.Unique)
)
public class ParentClass {
    @Id
    public Long id;
    public Date date;
}

@InheritIndices
public class ChildClass extends ParentClass {
    public String name;
}

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "title": "Nitrite Data Exchange Format",
  "description": "The data format for importing and exporting data out of Nitrite database.",
  "properties": {
    "collections": {
      "type": "array",
      "title": "List of all Nitrite Collections",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "title": "Name of the Collection"
          },
          "indices": {
            "type": "array",
            "title": "Indices",
            "items": {
              "type": "object",
              "properties": {
                "index": {
                  "type": "object",
                  "title": "Index",
                  "properties": {
                    "indexType": {
                      "type": "string",
                      "title": "Type of the Index"
                    },
                    "field": {
                      "type": "string",
                      "title": "Indexed field"
                    },
                    "collectionName": {
                      "type": "string",
                      "title": "Name of the Collection"
                    }
                  },
                  "required": [
                    "indexType",
                    "field",
                    "collectionName"
                  ]
                }
              },
              "required": [
                "index"
              ]
            }
          },
          "data": {
            "type": "array",
            "title": "Collection data format",
            "items": {
              "type": "object",
              "title": "NitriteId and Document pairs",
              "properties": {
                "key": {
                  "type": "object",
                  "title": "NitriteId",
                  "properties": {
                    "idType": {
                      "type": "string",
                      "title": "Type of ObjectId"
                    },
                    "objectId": {
                      "type": "object",
                      "title": "ObjectId"
                    }
                  },
                  "required": [
                    "idType",
                    "objectId"
                  ]
                },
                "value": {
                  "type": "object",
                  "title": "Document"
                }
              },
              "required": [
                "key",
                "value"
              ]
            }
          }
        },
        "required": [
          "name",
          "indices",
          "data"
        ]
      }
    },
    "repositories": {
      "type": "array",
      "title": "List of all Object Repositories",
      "items": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "title": "Type of the Object"
          },
          "indices": {
            "type": "array",
            "title": "Indices",
            "items": {
              "type": "object",
              "properties": {
                "index": {
                  "type": "object",
                  "title": "Index",
                  "properties": {
                    "indexType": {
                      "type": "string",
                      "title": "Type of the Index"
                    },
                    "field": {
                      "type": "string",
                      "title": "Indexed field"
                    },
                    "collectionName": {
                      "type": "string",
                      "title": "Internal name of the Object Repository"
                    }
                  },
                  "required": [
                    "indexType",
                    "field",
                    "collectionName"
                  ]
                }
              },
              "required": [
                "index"
              ]
            }
          },
          "data": {
            "type": "array",
            "title": "Repository data format",
            "items": {
              "type": "object",
              "title": "NitriteId and Document pairs",
              "properties": {
                "key": {
                  "type": "object",
                  "title": "NitriteId",
                  "properties": {
                    "idType": {
                      "type": "string",
                      "title": "Type of ObjectId"
                    },
                    "objectId": {
                      "type": "object",
                      "title": "ObjectId"
                    }
                  },
                  "required": [
                    "idType",
                    "objectId"
                  ]
                },
                "value": {
                  "type": "object",
                  "title": "Document"
                }
              },
              "required": [
                "key",
                "value"
              ]
            }
          }
        },
        "required": [
          "type",
          "indices",
          "data"
        ]
      }
    }
  },
  "required": [
    "collections",
    "repositories"
  ]
}