集計式演算子

val month = current().getDate("date").month(of("UTC"))
val precip = current().getInteger("precipitation")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.group(
            month,
            Accumulators.avg("avgPrecipMM", precip.multiply(25.4))
        )
    )
)

[ { $group: {
    _id: { $month: "$date" },
    avgPrecipMM: {
        $avg: { $multiply: ["$precipitation", 25.4] } }
} } ]

val showtimes = current().getArray<MqlDocument>("showtimes")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed("availableShowtimes", showtimes
                    .filter { showtime ->
                        val seats = showtime.getArray<MqlInteger>("seats")
                        val totalSeats = seats.sum { n -> n }
                        val ticketsBought = showtime.getInteger("ticketsBought")
                        val isAvailable = ticketsBought.lt(totalSeats)
                        isAvailable
                    })
            )
        )
    )
)

[ { $project: {
    availableShowtimes: {
        $filter: {
            input: "$showtimes",
            as: "showtime",
            cond: { $lt: [ "$$showtime.ticketsBought", { $sum: "$$showtime.seats" } ] }
    } }
} } ]

val temperature = current().getInteger("temperature")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed(
                    "extremeTemp", temperature
                        .lt(of(10))
                        .or(temperature.gt(of(95)))
                )
            )
        )
    )
)

[ { $project: {
    extremeTemp: { $or: [ { $lt: ["$temperature", 10] },
                          { $gt: ["$temperature", 95] } ] }
} } ]

val location = current().getString("location")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.match(
            Filters.expr(location.eq(of("California")))
        )
    )
)

[ { $match: { location: { $eq: "California" } } } ]

val member = current().getField("member")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed("membershipLevel",
                    member.switchOn { field ->
                        field
                            .isString { s -> s }
                            .isBoolean { b -> b.cond(of("Gold"), of("Guest")) }
                            .isArray { a -> a.last() }
                            .defaults { d -> of("Guest") }
                    })
            )
        )
    )
)

[ { $project: {
    membershipLevel: {
        $switch: {
          branches: [
            { case: { $eq: [ { $type: "$member" }, "string" ] }, then: "$member" },
            { case: { $eq: [ { $type: "$member" }, "bool" ] }, then: { $cond: {
                                                                           if: "$member",
                                                                           then: "Gold",
                                                                           else: "Guest" } } },
            { case: { $eq: [ { $type: "$member" }, "array" ] }, then: { $last: "$member" } }
          ],
          default: "Guest" } }
} } ]

fun gradeAverage(students: MqlArray<MqlDocument>, fieldName: String): MqlNumber {
    val sum = students.sum { student -> student.getInteger(fieldName) }
    val avg = sum.divide(students.size())
    return avg
}
fun evaluate(grade: MqlNumber, cutoff1: MqlNumber, cutoff2: MqlNumber): MqlString {
    val message = grade.switchOn { on ->
        on
            .lte(cutoff1) { g -> of("Needs improvement") }
            .lte(cutoff2) { g -> of("Meets expectations") }
            .defaults { g -> of("Exceeds expectations") }
    }
    return message
}

val students = current().getArray<MqlDocument>("students")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed("evaluation", students
                    .passArrayTo { s -> gradeAverage(s, "finalGrade") }
                    .passNumberTo { grade -> evaluate(grade, of(70), of(85)) })
            )
        )
    )
)

[ { $project: {
    evaluation: { $switch: {
        branches: [
            { case: { $lte: [ { $avg: "$students.finalGrade" }, 70 ] },
              then: "Needs improvement"
            },
            { case: { $lte: [ { $avg: "$students.finalGrade" }, 85 ] },
              then: "Meets expectations"
            }
        ],
        default: "Exceeds expectations" } }
} } ]

val students = current().getArray<MqlDocument>("students")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed("evaluation", students
                    .passArrayTo { s -> gradeAverage(s, "finalGrade") }
                    .passNumberTo { grade -> evaluate(grade, of(70), of(85)) })
            )
        )
    )
)

[ { $addFields: {
    reunionYear: {
        $add: [ { $toInt: "$graduationYear" }, 5 ] }
} } ]

val deliveryDate = current().getString("deliveryDate")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.match(
            Filters.expr(
                deliveryDate
                    .parseDate()
                    .dayOfWeek(of("America/New_York"))
                    .eq(of(2))
            )
        )
    )
)

[ { $match: {
    $expr: {
        $eq: [ {
            $dayOfWeek: {
                date: { $dateFromString: { dateString: "$deliveryDate" } },
                timezone: "America/New_York" }},
            2
        ] }
} } ]

val address = current().getDocument("mailing.address")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.match(
            Filters.expr(
                address
                    .getString("state")
                    .eq(of("WA"))
            )
        )
    )
)

[
    { $match: {
        $expr: {
            $eq: [{
                $getField: {
                    input: { $getField: { input: "$$CURRENT", field: "mailing.address"}},
                    field: "state" }},
                "WA" ]
}}}]

val warehouses = current().getMap<MqlNumber>("warehouses")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed("totalInventory", warehouses
                    .entries()
                    .sum { v -> v.getValue() })
            )
        )
    )
)

[ { $project: {
    totalInventory: {
        $sum: {
          $getField: { $objectToArray: "$warehouses" },
        } }
} } ]

val lastName = current().getString("lastName")
val employeeID = current().getString("employeeID")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed(
                    "username", lastName
                        .append(employeeID)
                        .toLower()
                )
            )
        )
    )
)

[ { $project: {
    username: {
        $toLower: { $concat: ["$lastName", "$employeeID"] } }
} } ]

val rating = current().getField("rating")
val results = collection.aggregate<Document>(
    listOf(
        Aggregates.project(
            Projections.fields(
                Projections.computed(
                    "numericalRating", rating
                        .isNumberOr(of(1))
                )
            )
        )
    )
)

[ { $project: {
    numericalRating: {
        $cond: { if: { $isNumber: "$rating" },
                 then: "$rating",
                 else: 1
        } }
} } ]