MongoDB 쿼리 - Java SDK

Plant plant = new Plant(
        new ObjectId(),
        "lily of the valley",
        "full",
        "white",
        "perennial",
        "Store 47");
mongoCollection.insertOne(plant).getAsync(task -> {
    if (task.isSuccess()) {
        Log.v("EXAMPLE", "successfully inserted a document with id: " + task.get().getInsertedId());
    } else {
        Log.e("EXAMPLE", "failed to insert documents with: " + task.getError().getErrorMessage());
    }
});

val plant = Plant(
    ObjectId(),
    "lily of the valley",
    "full",
    "white",
    "perennial",
    "Store 47"
)
mongoCollection?.insertOne(plant)?.getAsync { task ->
    if (task.isSuccess) {
        Log.v(
            "EXAMPLE",
            "successfully inserted a document with id: ${task.get().insertedId}"
        )
    } else {
        Log.e("EXAMPLE", "failed to insert documents with: ${task.error}")
    }
}

List<Plant> plants  = Arrays.asList(
        new Plant(new ObjectId(),
                "rhubarb",
                "full",
                "red",
                "perennial",
                "Store 47"),
        new Plant(new ObjectId(),
                "wisteria lilac",
                "partial",
                "purple",
                "perennial",
                "Store 42"),
        new Plant(new ObjectId(),
                "daffodil",
                "full",
                "yellow",
                "perennial",
                "Store 42"));
mongoCollection.insertMany(plants).getAsync(task -> {
    if (task.isSuccess()) {
        int insertedCount = task.get().getInsertedIds().size();
        Log.v("EXAMPLE", "successfully inserted " + insertedCount + " documents into the collection.");
    } else {
        Log.e("EXAMPLE", "failed to insert documents with: ", task.getError());
    }
});

val plants = listOf(
    Plant(
        ObjectId(),
        "rhubarb",
        "full",
        "red",
        "perennial",
        "Store 47"
    ),
    Plant(
        ObjectId(),
        "wisteria lilac",
        "partial",
        "purple",
        "perennial",
        "Store 42"
    ),
    Plant(
        ObjectId(),
        "daffodil",
        "full",
        "yellow",
        "perennial",
        "Store 42"
    )
)
mongoCollection.insertMany(plants).getAsync { task ->
    if (task.isSuccess) {
        val insertedCount = task.get().insertedIds.size
        Log.v(
            "EXAMPLE",
            "successfully inserted $insertedCount documents into the collection."
        )
    } else {
        Log.e("EXAMPLE", "failed to insert documents with: ${task.error}")
    }
}

Document queryFilter  = new Document("type", "perennial");
mongoCollection.findOne(queryFilter).getAsync(task -> {
    if (task.isSuccess()) {
        Plant result = task.get();
        Log.v("EXAMPLE", "successfully found a document: " + result);
    } else {
        Log.e("EXAMPLE", "failed to find document with: ", task.getError());
    }
});

val queryFilter = Document("type", "perennial")
mongoCollection.findOne(queryFilter)
    .getAsync { task ->
        if (task.isSuccess) {
            val result = task.get()
            Log.v("EXAMPLE", "successfully found a document: $result")
        } else {
            Log.e("EXAMPLE", "failed to find document with: ${task.error}")
        }
    }

Document queryFilter  = new Document("_partition", "Store 42");
RealmResultTask<MongoCursor<Plant>> findTask = mongoCollection.find(queryFilter).iterator();
findTask.getAsync(task -> {
    if (task.isSuccess()) {
        MongoCursor<Plant> results = task.get();
        Log.v("EXAMPLE", "successfully found all plants for Store 42:");
        while (results.hasNext()) {
            Log.v("EXAMPLE", results.next().toString());
        }
    } else {
        Log.e("EXAMPLE", "failed to find documents with: ", task.getError());
    }
});

val queryFilter = Document("_partition", "Store 42")
val findTask = mongoCollection.find(queryFilter).iterator()
findTask.getAsync { task ->
    if (task.isSuccess) {
        val results = task.get()
        Log.v("EXAMPLE", "successfully found all plants for Store 42:")
        while (results.hasNext()) {
            Log.v("EXAMPLE", results.next().toString())
        }
    } else {
        Log.e("EXAMPLE", "failed to find documents with: ${task.error}")
    }
}

mongoCollection.count().getAsync(task -> {
    if (task.isSuccess()) {
        long count = task.get();
        Log.v("EXAMPLE",
                "successfully counted, number of documents in the collection: " +
                        count);
    } else {
        Log.e("EXAMPLE", "failed to count documents with: ", task.getError());
    }
});

mongoCollection.count().getAsync { task ->
    if (task.isSuccess) {
        val count = task.get()
        Log.v("EXAMPLE", "successfully counted, number of documents in the collection: $count")
    } else {
        Log.e("EXAMPLE", "failed to count documents with: ${task.error}")
    }
}

Document queryFilter = new Document("name", "petunia");
Document updateDocument = new Document("$set", new Document("sunlight", "partial"));
mongoCollection.updateOne(queryFilter, updateDocument).getAsync(task -> {
    if (task.isSuccess()) {
        long count = task.get().getModifiedCount();
        if (count == 1) {
            Log.v("EXAMPLE", "successfully updated a document.");
        } else {
            Log.v("EXAMPLE", "did not update a document.");
        }
    } else {
        Log.e("EXAMPLE", "failed to update document with: ", task.getError());
    }
});

val queryFilter = Document("name", "petunia")
val updateDocument = Document("\$set", Document("sunlight", "partial"))
mongoCollection.updateOne(queryFilter, updateDocument).getAsync { task ->
    if (task.isSuccess) {
        val count = task.get().modifiedCount
        if (count == 1L) {
            Log.v("EXAMPLE", "successfully updated a document.")
        } else {
            Log.v("EXAMPLE", "did not update a document.")
        }
    } else {
        Log.e("EXAMPLE", "failed to update document with: ${task.error}")
    }
}

Document queryFilter = new Document("_partition", "Store 47");
Document updateDocument = new Document("$set", new Document("_partition", "Store 51"));
mongoCollection.updateMany(queryFilter, updateDocument).getAsync(task -> {
    if (task.isSuccess()) {
        long count = task.get().getModifiedCount();
        if (count != 0) {
            Log.v("EXAMPLE", "successfully updated " + count + " documents.");
        } else {
            Log.v("EXAMPLE", "did not update any documents.");
        }
    } else {
        Log.e("EXAMPLE", "failed to update documents with: ", task.getError());
    }
});

val queryFilter = Document("_partition", "Store 47")
val updateDocument = Document("\$set", Document("_partition", "Store 51"))
mongoCollection.updateMany(queryFilter, updateDocument).getAsync { task ->
    if (task.isSuccess) {
        val count = task.get().modifiedCount
        if (count != 0L) {
            Log.v("EXAMPLE", "successfully updated $count documents.")
        } else {
            Log.v("EXAMPLE", "did not update any documents.")
        }
    } else {
        Log.e("EXAMPLE", "failed to update documents with: ${task.error}")
    }
}

Document queryFilter = new Document("sunlight", "full")
        .append("type", "perennial")
        .append("color", "green")
        .append("_partition", "Store 47");
Document updateDocument = new Document("$set", new Document("name", "sweet basil"));
UpdateOptions updateOptions = new UpdateOptions().upsert(true);
mongoCollection.updateOne(queryFilter, updateDocument, updateOptions).getAsync(task -> {
    if (task.isSuccess()) {
        if(task.get().getUpsertedId() != null) {
            Log.v("EXAMPLE", "successfully upserted a document with id " +
                    task.get().getUpsertedId());
        } else {
            Log.v("EXAMPLE", "successfully updated a document.");
        }
    } else {
        Log.e("EXAMPLE", "failed to update or insert document with: ",
                task.getError());
    }
});

val queryFilter = Document("sunlight", "full")
    .append("type", "perennial")
    .append("color", "green")
    .append("_partition", "Store 47")
val updateDocument = Document("\$set", Document("name", "sweet basil"))
val updateOptions = UpdateOptions().upsert(true)
mongoCollection.updateOne(queryFilter, updateDocument, updateOptions)
    .getAsync { task ->
        if (task.isSuccess) {
            if (task.get().upsertedId != null) {
                Log.v("EXAMPLE", "successfully upserted a document with id ${task.get().upsertedId}")
            } else {
                Log.v("EXAMPLE", "successfully updated a document.")
            }
        } else {
            Log.e("EXAMPLE", "failed to update or insert document with: ${task.error}")
        }
    }

Document queryFilter = new Document("color", "green");
mongoCollection.deleteOne(queryFilter).getAsync(task -> {
    if (task.isSuccess()) {
        long count = task.get().getDeletedCount();
        if (count == 1) {
            Log.v("EXAMPLE", "successfully deleted a document.");
        } else {
            Log.v("EXAMPLE", "did not delete a document.");
        }
    } else {
        Log.e("EXAMPLE", "failed to delete document with: ", task.getError());
    }
});

val queryFilter = Document("color", "green")
mongoCollection.deleteOne(queryFilter).getAsync { task ->
    if (task.isSuccess) {
        val count = task.get().deletedCount
        if (count == 1L) {
            Log.v("EXAMPLE", "successfully deleted a document.")
        } else {
            Log.v("EXAMPLE", "did not delete a document.")
        }
    } else {
        Log.e("EXAMPLE", "failed to delete document with: ${task.error}")
    }
}

Document queryFilter = new Document("sunlight", "full")
        .append("type", "annual");
mongoCollection.deleteMany(queryFilter).getAsync(task -> {
    if (task.isSuccess()) {
        long count = task.get().getDeletedCount();
        if (count != 0) {
            Log.v("EXAMPLE", "successfully deleted " + count + " documents.");
        } else {
            Log.v("EXAMPLE", "did not delete any documents.");
        }
    } else {
        Log.e("EXAMPLE", "failed to delete documents with: ", task.getError());
    }
});

val queryFilter = Document("sunlight", "full").append("type", "annual")
mongoCollection.deleteMany(queryFilter).getAsync { task ->
    if (task.isSuccess) {
        val count = task.get().deletedCount
        if (count != 0L) {
            Log.v("EXAMPLE", "successfully deleted $count documents.")
        } else {
            Log.v("EXAMPLE", "did not delete any documents.")
        }
    } else {
        Log.e("EXAMPLE", "failed to delete documents with: ${task.error}")
    }
}

RealmEventStreamAsyncTask<Plant> watcher = mongoCollection.watchAsync();
watcher.get(result -> {
    if (result.isSuccess()) {
        Log.v("EXAMPLE", "Event type: " +
                result.get().getOperationType() + " full document: " +
                result.get().getFullDocument());
    } else {
        Log.e("EXAMPLE", "failed to subscribe to changes in the collection with : ",
                result.getError());
    }
});
Plant triffid = new Plant(
        new ObjectId(),
        "triffid",
        "low",
        "green",
        "perennial",
        "Store 47");
mongoCollection.insertOne(triffid).getAsync(task -> {
    if (task.isSuccess()) {
        BsonObjectId insertedId = task.get().getInsertedId().asObjectId();
        Log.v("EXAMPLE", "successfully inserted a document with id " + insertedId);
    } else {
        Log.e("EXAMPLE", "failed to insert document with: ", task.getError());
    }
});

val watcher = mongoCollection.watchAsync()
watcher[{ result ->
    if (result.isSuccess) {
        Log.v("EXAMPLE", "Event type: ${result.get().operationType} full document: ${result.get().fullDocument}")
    } else {
        Log.e("EXAMPLE", "failed to subscribe to changes in the collection with : ${result.error}")
    }
}]
val triffid =
    Plant(
        ObjectId(),
        "triffid",
        "low",
        "green",
        "perennial",
        "Store 47"
    )
mongoCollection.insertOne(triffid).getAsync { task ->
    if (task.isSuccess) {
        val insertedId = task.get().insertedId.asObjectId()
        Log.v("EXAMPLE", "successfully inserted a document with id $insertedId")
    } else {
        Log.e("EXAMPLE", "failed to insert document with: ${task.error}")
    }
}

RealmEventStreamAsyncTask<Plant> watcher = mongoCollection
        .watchWithFilterAsync(new Document("fullDocument._partition", "Store 42"));
watcher.get(result -> {
    if (result.isSuccess()) {
        Log.v("EXAMPLE", "Event type: " +
                result.get().getOperationType() + " full document: " +
                result.get().getFullDocument());
    } else {
        Log.e("EXAMPLE",
                "failed to subscribe to filtered changes in the collection with : ",
                result.getError());
    }
});
List<Plant> plants  = Arrays.asList(
        new Plant(
                new ObjectId(),
                "triffid",
                "low",
                "green",
                "perennial",
                "Store 47"),
        new Plant(
                new ObjectId(),
                "venomous tentacula",
                "low",
                "brown",
                "annual",
                "Store 42"
        ));
mongoCollection.insertMany(plants).getAsync(task -> {
    if (task.isSuccess()) {
        int insertedCount = task.get().getInsertedIds().size();
        Log.v("EXAMPLE", "successfully inserted " +
                insertedCount + " documents into the collection.");
    } else {
        Log.e("EXAMPLE", "failed to insert documents with: ",
                task.getError());
    }
});

val watcher = mongoCollection
    .watchWithFilterAsync(Document("fullDocument._partition", "Store 42"))
watcher[{ result ->
    if (result.isSuccess) {
        Log.v("EXAMPLE", "Event type: ${result.get().operationType} full document: ${result.get().fullDocument}")
    } else {
        Log.e("EXAMPLE", "failed to subscribe to filtered changes in the collection with : ${result.error}")
    }
}]
val plants = listOf(
    Plant(
        ObjectId(),
        "triffid",
        "low",
        "green",
        "perennial",
        "Store 47"
    ),
    Plant(
        ObjectId(),
        "venomous tentacula",
        "low",
        "brown",
        "annual",
        "Store 42"
    )
)
mongoCollection.insertMany(plants).getAsync { task ->
    if (task.isSuccess) {
        val insertedCount = task.get().insertedIds.size
        Log.v("EXAMPLE", "successfully inserted $insertedCount documents into the collection.")
    } else {
        Log.e("EXAMPLE", "failed to insert documents with: ${task.error}")
    }
}

// create an aggregation pipeline
List<Document> pipeline = Arrays.asList(
        new Document("$group", new Document("_id", "$type")
                .append("totalCount", new Document("$sum", 1))));
// query mongodb using the pipeline
RealmResultTask<MongoCursor<Document>> aggregationTask =
        mongoCollection.aggregate(pipeline).iterator();
// handle success or failure of the query
aggregationTask.getAsync(task -> {
    if (task.isSuccess()) {
        MongoCursor<Document> results = task.get();
        // iterate over and print the results to the log
        Log.v("EXAMPLE", "successfully aggregated the plants. Results:");
        while (results.hasNext()) {
            Log.v("EXAMPLE", results.next().toString());
        }
    } else {
        Log.e("EXAMPLE", "failed to aggregate documents with: ",
                task.getError());
    }
});

// create an aggregation pipeline
val pipeline =
    listOf(
        Document("\$group",
            Document("_id", "\$type")
                .append("totalCount", Document("\$sum", 1))
        )
    )
// query mongodb using the pipeline
val aggregationTask = mongoCollection.aggregate(pipeline).iterator()
// handle success or failure of the query
aggregationTask.getAsync { task: App.Result<MongoCursor<Document>> ->
    if (task.isSuccess) {
        val results = task.get()
        // iterate over and print the results to the log
        Log.v("EXAMPLE",
            "successfully aggregated the plants. Results:")
        while (results.hasNext()) {
            Log.v("EXAMPLE", results.next().toString())
        }
    } else {
        Log.e("EXAMPLE",
            "failed to aggregate documents with: ${task.error}")
    }
}