Documents

doc.setValue("createdAt", Date())
val date = doc.getDate("createdAt")

newTask.setValue("createdAt", new Date());
Date date = newTask.getDate("createdAt");

// NOTE: No error handling, for brevity (see getting started)
val document = collection.getDocument("doc1")

// Getting a dictionary from the document's properties
val dict = document?.getDictionary("address")

// Access a value with a key from the dictionary
val street = dict?.getString("street")

// Iterate dictionary
dict?.forEach { println("${it} -> ${dict.getValue(it)}") }

// Create a mutable copy
val mutableDict = dict?.toMutable()

// NOTE: No error handling, for brevity (see getting started)
Document document = collection.getDocument("doc1");
if (document == null) { return; }

// Getting a dictionary from the document's properties
Dictionary dict = document.getDictionary("address");
if (dict == null) { return; }

// Access a value with a key from the dictionary
String street = dict.getString("street");

// Iterate dictionary
for (String key: dict.getKeys()) {
    System.out.println("Key " + key + " = " + dict.getValue(key));
}

// Create a mutable copy
MutableDictionary mutableDict = dict.toMutable();

// NOTE: No error handling, for brevity (see getting started)

// Create a new mutable dictionary and populate some keys/values
val mutableDict = MutableDictionary()
mutableDict.setString("street", "1 Main st.")
mutableDict.setString("city", "San Francisco")

// Add the dictionary to a document's properties and save the document
val mutableDoc = MutableDocument("doc1")
mutableDoc.setDictionary("address", mutableDict)
collection.save(mutableDoc)

// NOTE: No error handling, for brevity (see getting started)

// Create a new mutable dictionary and populate some keys/values
MutableDictionary mutableDict = new MutableDictionary();
mutableDict.setString("street", "1 Main st.");
mutableDict.setString("city", "San Francisco");

// Add the dictionary to a document's properties and save the document
MutableDocument mutableDoc = new MutableDocument("doc1");
mutableDoc.setDictionary("address", mutableDict);
collection.save(mutableDoc);

// NOTE: No error handling, for brevity (see getting started)

val document = collection.getDocument("doc1")

// Getting a phones array from the document's properties
val array = document?.getArray("phones")

// Get element count
val count = array?.count()

// Access an array element by index
val phone = array?.getString(1)

// Iterate array
array?.forEachIndexed { index, item -> println("Row  ${index} = ${item}") }

// Create a mutable copy
val mutableArray = array?.toMutable()

// NOTE: No error handling, for brevity (see getting started)

Document document = collection.getDocument("doc1");
if (document == null) { return; }

// Getting a phones array from the document's properties
Array array = document.getArray("phones");
if (array == null) { return; }

// Get element count
int count = array.count();

// Access an array element by index
String phone = array.getString(1);

// Iterate array
for (int i = 0; i < count; i++) {
    System.out.println("Row  " + i + " = " + array.getString(i));
}

// Create a mutable copy
MutableArray mutableArray = array.toMutable();

// NOTE: No error handling, for brevity (see getting started)

// Create a new mutable array and populate data into the array
val mutableArray = MutableArray()
mutableArray.addString("650-000-0000")
mutableArray.addString("650-000-0001")

// Set the array to document's properties and save the document
val mutableDoc = MutableDocument("doc1")
mutableDoc.setArray("phones", mutableArray)
collection.save(mutableDoc)

// NOTE: No error handling, for brevity (see getting started)

// Create a new mutable array and populate data into the array
MutableArray mutableArray = new MutableArray();
mutableArray.addString("650-000-0000");
mutableArray.addString("650-000-0001");

// Set the array to document's properties and save the document
MutableDocument mutableDoc = new MutableDocument("doc1");
mutableDoc.setArray("phones", mutableArray);
collection.save(mutableDoc);

// github tag=tojson-array
val mArray = MutableArray(JSON) (1)
for (i in 0 until mArray.count()) {
    mArray.getDictionary(i)?.apply {
        log(getString("name") ?: "unknown")
        collection.save(MutableDocument(getString("id"), toMap()))
    } (2)
}

collection.getDocument("1002")?.getArray("features")?.apply {
    for (feature in toList()) {
        log("$feature")
    } (3)
    log(toJSON())
} (4)

// github tag=tojson-array
final MutableArray mArray = new MutableArray(JSON); (1)

for (int i = 0; i < mArray.count(); i++) { (2)
    final Dictionary dict = mArray.getDictionary(i);
    Logger.log(dict.getString("name"));
    collection.save(new MutableDocument(dict.getString("id"), dict.toMap()));
}

final Array features = collection.getDocument("1002").getArray("features");
for (Object feature: features.toList()) { Logger.log(feature.toString()); }
Logger.log(features.toJSON()); (3)

// github tag=tojson-blob
val thisBlob = collection.getDocument("thisdoc-id")!!.toMap()
if (!Blob.isBlob(thisBlob)) {
    return
}
val blobType = thisBlob["content_type"].toString()
val blobLength = thisBlob["length"] as Number?

// github tag=tojson-blob
final Map<String, ?> thisBlob = collection.getDocument("thisdoc-id").toMap();
if (!Blob.isBlob(thisBlob)) { return; }

final String blobType = thisBlob.get("content_type").toString();
final Number blobLength = (Number) thisBlob.get("length");

// github tag=tojson-dictionary
val mDict = MutableDictionary(JSON) (1)
log("$mDict")
log("Details for: ${mDict.getString("name")}")
mDict.keys.forEach { key ->
    log(key + " => " + mDict.getValue(key))
}

// github tag=tojson-dictionary
final MutableDictionary mDict = new MutableDictionary(JSON); (1)
Logger.log(mDict.toString());

Logger.log("Details for: " + mDict.getString("name"));
for (String key: mDict.getKeys()) {
    Logger.log(key + " => " + mDict.getValue(key));
}

QueryBuilder
    .select(SelectResult.expression(Meta.id).`as`("metaId"))
    .from(DataSource.collection(srcColl))
    .execute()
    .forEach {
        it.getString("metaId")?.let { thisId ->
            srcColl.getDocument(thisId)?.toJSON()?.let { json -> (1)
                log("JSON String = $json")
                val hotelFromJSON = MutableDocument(thisId, json) (2)
                dstColl.save(hotelFromJSON)
                dstColl.getDocument(thisId)?.toMap()?.forEach { e ->
                    log("$e.key => $e.value")
                } (3)
            }
        }
    }

// github tag=tojson-document
final Query listQuery = QueryBuilder
    .select(SelectResult.expression(Meta.id).as("metaId"))
    .from(DataSource.collection(srcColl));

try (ResultSet results = listQuery.execute()) {
    for (Result row: results) {
        final String thisId = row.getString("metaId");

        final String json = srcColl.getDocument(thisId).toJSON(); (1)
        Logger.log("JSON String = " + json);

        final MutableDocument hotelFromJSON = new MutableDocument(thisId, json); (2)

        dstColl.save(hotelFromJSON);

        for (Map.Entry<String, Object> entry: dstColl.getDocument(thisId).toMap().entrySet()) {
            Logger.log(entry.getKey() + " => " + entry.getValue()); (3)
        }
    }
}

// Uses Jackson JSON processor
val mapper = ObjectMapper()
val hotels = mutableListOf<Hotel>()

listQuery.execute().use { rs ->
    rs.forEach {

        // Get result as JSON string
        val json = it.toJSON() (1)

        // Get Hashmap from JSON string
        val dictFromJSONstring = mapper.readValue(json, HashMap::class.java) (2)

        // Use created hashmap
        val hotelId = dictFromJSONstring["id"].toString() //
        val hotelType = dictFromJSONstring["type"].toString()
        val hotelname = dictFromJSONstring["name"].toString()

        // Get custom object from JSON string
        val thisHotel = mapper.readValue(json, Hotel::class.java) (3)
        hotels.add(thisHotel)
    }
}

// Uses Jackson JSON processor
ObjectMapper mapper = new ObjectMapper();
List<Hotel> hotels = new ArrayList<>();

try (ResultSet rs = listQuery.execute()) {
    for (Result result: rs) {
        String json = result.toJSON();
        Map<String, String> dictFromJSONstring = mapper.readValue(json, HashMap.class);

        String hotelId = dictFromJSONstring.get("id");
        String hotelType = dictFromJSONstring.get("type");
        String hotelname = dictFromJSONstring.get("name");

        // Get custom object from JSON string
        Hotel thisHotel = mapper.readValue(json, Hotel.class);
        hotels.add(thisHotel);
    }
}