Introdução ao MongoDB Kotlin Driver

1
dependencies {
2
    // Kotlin coroutine dependency
3
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
4
    
5
    // MongoDB Kotlin driver dependency
6
    implementation("org.mongodb:mongodb-driver-kotlin-coroutine:4.10.1")
7
}

1
val connectionString = "mongodb+srv://<username>:<enter your password>@cluster0.sq3aiau.mongodb.net/?retryWrites=true&w=majority"
2
val client = MongoClient.create(connectionString = connectString)

1
val databaseName = "sample_restaurants"
2
val db: MongoDatabase = client.getDatabase(databaseName = databaseName)

1
suspend fun setupConnection(
2
    databaseName: String = "sample_restaurants",
3
    connectionEnvVariable: String = "MONGODB_URI"
4
): MongoDatabase? {
5
    val connectString = if (System.getenv(connectionEnvVariable) != null) {
6
        System.getenv(connectionEnvVariable)
7
    } else {
8
        "mongodb+srv://<usename>:<password>@cluster0.sq3aiau.mongodb.net/?retryWrites=true&w=majority"
9
    }
10
11
    val client = MongoClient.create(connectionString = connectString)
12
    val database = client.getDatabase(databaseName = databaseName)
13
14
    return try {
15
        // Send a ping to confirm a successful connection
16
        val command = Document("ping", BsonInt64(1))
17
        database.runCommand(command)
18
        println("Pinged your deployment. You successfully connected to MongoDB!")
19
        database
20
    } catch (me: MongoException) {
21
        System.err.println(me)
22
        null
23
    }
24
}

1
suspend fun listAllCollection(database: MongoDatabase) {
2
3
    val count = database.listCollectionNames().count()
4
    println("Collection count $count")
5
6
    print("Collection in this database are -----------> ")
7
    database.listCollectionNames().collect { print(" $it") }
8
}

1
suspend fun dropCollection(database: MongoDatabase) {
2
    database.getCollection<Objects>(collectionName = "restaurants").drop()
3
}

1
data class Restaurant(
2
    @BsonId
3
    val id: ObjectId,
4
    val address: Address,
5
    val borough: String,
6
    val cuisine: String,
7
    val grades: List<Grade>,
8
    val name: String,
9
    @BsonProperty("restaurant_id")
10
    val restaurantId: String
11
)
12
13
data class Address(
14
    val building: String,
15
    val street: String,
16
    val zipcode: String,
17
    val coord: List<Double>
18
)
19
20
data class Grade(
21
    val date: LocalDateTime,
22
    val grade: String,
23
    val score: Int
24
)

1
suspend fun addItem(database: MongoDatabase) {
2
3
    val collection = database.getCollection<Restaurant>(collectionName = "restaurants")
4
    val item = Restaurant(
5
        id = ObjectId(),
6
        address = Address(
7
            building = "Building", street = "street", zipcode = "zipcode", coord =
8
            listOf(Random.nextDouble(), Random.nextDouble())
9
        ),
10
        borough = "borough",
11
        cuisine = "cuisine",
12
        grades = listOf(
13
            Grade(
14
                date = LocalDateTime.now(),
15
                grade = "A",
16
                score = Random.nextInt()
17
            )
18
        ),
19
        name = "name",
20
        restaurantId = "restaurantId"
21
    )
22
23
    collection.insertOne(item).also {
24
        println("Item added with id - ${it.insertedId}")
25
    }
26
}

1
suspend fun addItems(database: MongoDatabase) {
2
    val collection = database.getCollection<Restaurant>(collectionName = "restaurants")
3
    val newRestaurants = collection.find<Restaurant>().first().run {
4
        listOf(
5
            this.copy(
6
                id = ObjectId(), name = "Insert Many Restaurant first", restaurantId = Random
7
                    .nextInt().toString()
8
            ),
9
            this.copy(
10
                id = ObjectId(), name = "Insert Many Restaurant second", restaurantId = Random
11
                    .nextInt().toString()
12
            )
13
        )
14
    }
15
16
    collection.insertMany(newRestaurants).also {
17
        println("Total items added ${it.insertedIds.size}")
18
    }
19
}

1
val collection = database.getCollection<Restaurant>(collectionName = "restaurants")
2
collection.find<Restaurant>().limit(1).collect {
3
    println(it)
4
}

1
val queryParams = Filters
2
    .and(
3
        listOf(
4
            eq("cuisine", "American"),
5
            eq("borough", "Queens")
6
        )
7
    )

1
suspend fun readSpecificDocument(database: MongoDatabase) {
2
    val collection = database.getCollection<Restaurant>(collectionName = "restaurants")
3
    val queryParams = Filters
4
        .and(
5
            listOf(
6
                eq("cuisine", "American"),
7
                eq("borough", "Queens")
8
            )
9
        )
10
11
12
    collection
13
        .find<Restaurant>(queryParams)
14
        .limit(2)
15
        .collect {
16
            println(it)
17
        }
18
19
}

1
suspend fun readWithPaging(database: MongoDatabase, offset: Int, pageSize: Int) {
2
    val collection = database.getCollection<Restaurant>(collectionName = "restaurants")
3
    val queryParams = Filters
4
        .and(
5
            listOf(
6
                eq(Restaurant::cuisine.name, "American"),
7
                eq(Restaurant::borough.name, "Queens")
8
            )
9
        )
10
11
    collection
12
        .find<Restaurant>(queryParams)
13
        .limit(pageSize)
14
        .skip(offset)
15
        .collect {
16
            println(it)
17
        }
18
}

1
val collection = database.getCollection<Restaurant>(collectionName = "restaurants")
2
val options = IndexOptions().apply {
3
    this.name("restaurant_id_index")
4
    this.background(true)
5
}
6
7
collection.createIndex(
8
    keys = Indexes.ascending("restaurant_id"),
9
    options = options
10
)

1
val collection = db.getCollection<Restaurant>("restaurants")
2
val queryParam = Filters.eq("restaurant_id", "restaurantId")

1
val updateParams = Updates.set("restaurant_id", Random.nextInt().toString())

1
collection.updateOne(filter = queryParam, update = updateParams).also {
2
    println("Total docs modified ${it.matchedCount} and fields modified ${it.modifiedCount}")
3
}

1
suspend fun updateMultipleDocuments(db: MongoDatabase) {
2
    val collection = db.getCollection<Restaurant>("restaurants")
3
    val queryParam = Filters.eq(Restaurant::cuisine.name, "Chinese")
4
    val updateParams = Updates.combine(
5
        Updates.set(Restaurant::cuisine.name, "Indian"),
6
        Updates.set(Restaurant::borough.name, "Brooklyn")
7
    )
8
9
    collection.updateMany(filter = queryParam, update = updateParams).also {
10
        println("Total docs matched ${it.matchedCount} and modified ${it.modifiedCount}")
11
    }
12
}

1
val collection = db.getCollection<Restaurant>(collectionName = "restaurants")
2
val queryParams = Filters.eq("restaurant_id", "restaurantId")
3
4
collection.findOneAndDelete(filter = queryParams).also {
5
    it?.let {
6
        println(it)
7
    }
8
}

1
suspend fun deleteRestaurants(db: MongoDatabase) {
2
    val collection = db.getCollection<Restaurant>(collectionName = "restaurants")
3
4
    val queryParams = Filters.or(
5
        listOf(
6
            Filters.regex(Restaurant::name.name, Pattern.compile("^Insert")),
7
            Filters.regex("restaurant_id", Pattern.compile("^restaurant"))
8
        )
9
    )
10
    collection.deleteMany(filter = queryParams).also {
11
        println("Document deleted : ${it.deletedCount}")
12
    }
13
}