집계 표현식 연산

val month = current().getDate("date").month(of("UTC"))
val precip = current().getInteger("precipitation")
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")
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")
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")
listOf(
    Aggregates.match(
        Filters.expr(location.eq(of("California")))
))

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

val member = current().getField("member")
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")
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 graduationYear = current().getString("graduationYear")
listOf(
    Aggregates.addFields(
        Field("reunionYear",
            graduationYear
                .parseInteger()
                .add(5))
))

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

val deliveryDate = current().getString("deliveryDate")
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")
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")
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")
listOf(
    Aggregates.project(
        Projections.fields(
            Projections.computed("username", lastName
                .append(employeeID)
                .toLower())
)))

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

val rating = current().getField("rating")
listOf(
    Aggregates.project(
        Projections.fields(
            Projections.computed("numericalRating", rating
                .isNumberOr(of(1)))
)))

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