Construtores de expressões de agregação Java no MongoDB

1
db.orders.aggregate(
2
[
3
  {
4
    $match:
5
      {
6
        orderDate: {
7
          $gte: ISODate("2023-01-01"),
8
        },
9
        orderDate: {
10
          $lte: ISODate("2023-03-31"),
11
        },
12
      },
13
  },
14
  {
15
    $group:
16
      {
17
        _id: "$productType",
18
        count: {
19
          $sum: 1
20
        },
21
      },
22
  },
23
])

1
…
2
MongoDatabase database = mongoClient.getDatabase("Mighty_Products");
3
MongoCollection<Document> collection = database.getCollection("orders");
4
5
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
6
7
Bson matchStage = new Document("$match",
8
   new Document("orderDate",
9
   new Document("$gte",
10
   formatter.parse("2023-01-01")))
11
           .append("orderDate",
12
   new Document("$lte",
13
   formatter.parse("2023-03-31"))));
14
15
Bson groupStage = new Document("$group",
16
   new Document("_id", "$productType")
17
           .append("count",
18
   new Document("$sum", 1L)));
19
20
collection.aggregate(
21
       Arrays.asList(
22
               matchStage,
23
               groupStage
24
       )
25
).forEach(doc -> System.out.println(doc.toJson()));

1
MongoDatabase database = mongoClient.getDatabase("Mighty_Products");
2
MongoCollection<Document> collection = database.getCollection("orders");
3
4
var orderDate = current().getDate("orderDate");
5
Bson matchStage = match(expr(orderDate.gte(of(Instant.parse("2023-01-01")))
6
       .and(orderDate.lte(of(Instant.parse("2023-03-31"))))));
7
8
Bson groupStage = group(current().getString("productType"), sum("count", 1L));
9
10
collection.aggregate(
11
       Arrays.asList(
12
               matchStage,
13
               groupStage
14
       )
15
).forEach(doc -> System.out.println(doc.toJson()));

1
{
2
   "_id": {
3
       "$numberLong": "11262117"
4
   },
5
   "model": "B737",
6
   "tailNum": "N8620H",
7
   "positionReports": [
8
       {
9
           "callsign": "SWA962",
10
           "alt": {
11
               "$numberLong": "12625"
12
           },
13
           "lat": {
14
               "$numberDecimal": "39.782833"
15
           },
16
           "lng": {
17
               "$numberDecimal": "-104.49988"
18
           },
19
           "speed": {
20
               "$numberLong": "283"
21
           },
22
           "track": {
23
               "$numberLong": "345"
24
           },
25
           "vvel": {
26
               "$numberLong": "-1344"
27
           },
28
           "timestamp": {
29
               "$date": "2023-01-31T23:28:26.294Z"
30
           }
31
       },
32
       {
33
           "callsign": "SWA962",
34
           "alt": {
35
               "$numberLong": "12600"
36
           },
37
           "lat": {
38
               "$numberDecimal": "39.784744"
39
           },
40
           "lng": {
41
               "$numberDecimal": "-104.50058"
42
           },
43
           "speed": {
44
               "$numberLong": "283"
45
           },
46
           "track": {
47
               "$numberLong": "345"
48
           },
49
           "vvel": {
50
               "$numberLong": "-1344"
51
           },
52
           "timestamp": {
53
               "$date": "2023-01-31T23:28:26.419Z"
54
           }
55
       },
56
       {
57
           "callsign": "SWA962",
58
           "alt": {
59
               "$numberLong": "12600"
60
           },
61
           "lat": {
62
               "$numberDecimal": "39.78511"
63
           },
64
           "lng": {
65
               "$numberDecimal": "-104.50071"
66
           },
67
           "speed": {
68
               "$numberLong": "283"
69
           },
70
           "track": {
71
               "$numberLong": "345"
72
           },
73
           "vvel": {
74
               "$numberLong": "-1344"
75
           },
76
           "timestamp": {
77
               "$date": "2023-01-31T23:28:26.955Z"
78
           }
79
       }
80
   ]
81
}

1
{
2
    $match: {
3
      positionReports: {
4
        $elemMatch: {
5
          callsign: /^UAL/,
6
          $and: [
7
            {
8
              timestamp: {
9
                $gte: ISODate(
10
                  "2023-01-31T12:00:00.000-07:00"
11
                )
12
              }
13
            },
14
            {
15
              timestamp: {
16
                $lt: ISODate(
17
                  "2023-02-01T00:00:00.000-07:00"
18
                )
19
              }
20
            }
21
          ]
22
        }
23
      }
24
    }
25
  }

1
//Create the from and to dates for the match stage
2
String sFromDate = "2023-01-31T12:00:00.000-07:00";
3
TemporalAccessor ta = DateTimeFormatter.ISO_INSTANT.parse(sFromDate);
4
Instant fromInstant = Instant.from(ta);
5
Date fromDate = Date.from(fromInstant);
6
7
String sToDate = "2023-02-01T00:00:00.000-07:00";
8
ta = DateTimeFormatter.ISO_INSTANT.parse(sToDate);
9
Instant toInstant = Instant.from(ta);
10
Date toDate = Date.from(toInstant);
11
12
Document matchStage = new Document("$match",
13
        new Document("positionReports",
14
                new Document("$elemMatch",
15
                        new Document("callsign", Pattern.compile("^UAL"))
16
                                .append("$and", Arrays.asList(
17
                                    new Document("timestamp", new Document("$gte", fromDate)),
18
                                    new Document("timestamp", new Document("$lt", toDate))
19
                                ))
20
                )
21
        )
22
);

1
import static com.mongodb.client.model.Aggregates.*;
2
import static com.mongodb.client.model.Filters.*;
3
import static com.mongodb.client.model.Projections.*;
4
import static com.mongodb.client.model.Accumulators.*;
5
import static com.mongodb.client.model.mql.MqlValues.*;
6
//...
7
8
//Create the from and to dates for the match stage
9
String sFromDate = "2023-01-31T12:00:00.000-07:00";
10
TemporalAccessor ta = DateTimeFormatter.ISO_INSTANT.parse(sFromDate);
11
Instant fromInstant = Instant.from(ta);
12
13
String sToDate = "2023-02-01T00:00:00.000-07:00";
14
ta = DateTimeFormatter.ISO_INSTANT.parse(sToDate);
15
Instant toInstant = Instant.from(ta);
16
17
var positionReports = current().<MqlDocument>getArray("positionReports");
18
Bson matchStage = match(expr(
19
      positionReports.any(positionReport -> {
20
          var callsign = positionReport.getString("callsign");
21
          var ts = positionReport.getDate("timestamp");
22
          return callsign
23
                  .substr(0,3)
24
                  .eq(of("UAL"))
25
                  .and(ts.gte(of(fromInstant)))
26
                  .and(ts.lt(of(toInstant)));
27
      })
28
));

1
{
2
   $group:
3
   {
4
      _id: "$model",
5
      aircraftSet: {
6
         $addToSet: "$tailNum",
7
      },
8
   },
9
}

1
{
2
  "_id": "B757",
3
  "aircraftSet": [
4
    "N74856",
5
    "N77865",
6
    "N17104",
7
    "N19117",
8
    "N14120",
9
    "N57855",
10
    "N77871"
11
  ]
12
}

1
Bson bGroupStage = group(current().getString("model"),
2
       addToSet("aircraftSet", current().getString("tailNum")));

1
{
2
    $project: {
3
      airline: "United",
4
      model: "$_id",
5
      count: {
6
        $size: "$aircraftSet",
7
      },
8
      manufacturer: {
9
        $let: {
10
          vars: {
11
            manufacturerPrefix: {
12
              $substrBytes: ["$_id", 0, 1],
13
            },
14
          },
15
          in: {
16
            $switch: {
17
              branches: [
18
                {
19
                  case: {
20
                    $eq: [
21
                      "$$manufacturerPrefix",
22
                      "A",
23
                    ],
24
                  },
25
                  then: "AIRBUS",
26
                },
27
                {
28
                  case: {
29
                    $eq: [
30
                      "$$manufacturerPrefix",
31
                      "B",
32
                    ],
33
                  },
34
                  then: "BOEING",
35
                },
36
                {
37
                  case: {
38
                    $eq: [
39
                      "$$manufacturerPrefix",
40
                      "C",
41
                    ],
42
                  },
43
                  then: "CANADAIR",
44
                },
45
                {
46
                  case: {
47
                    $eq: [
48
                      "$$manufacturerPrefix",
49
                      "E",
50
                    ],
51
                  },
52
                  then: "EMBRAER",
53
                },
54
                {
55
                  case: {
56
                    $eq: [
57
                      "$$manufacturerPrefix",
58
                      "M",
59
                    ],
60
                  },
61
                  then: "MCDONNELL DOUGLAS",
62
                },
63
              ],
64
              default: "UNKNOWN",
65
            },
66
          },
67
        },
68
      },
69
      _id: "$$REMOVE",
70
    },
71
  }

1
{
2
  "airline": "United",
3
  "model": "B777",
4
  "count": 5,
5
  "Manufacturer": "BOEING"
6
}

1
Bson bProjectStage = project(fields(
2
       computed("airline", "United"),
3
       computed("model", current().getString("_id")),
4
       computed("count", current().<MqlDocument>getArray("aircraftSet").size()),
5
       computed("manufacturer", current()
6
               .getString("_id")
7
               .substr(0, 1)
8
               .switchStringOn(s -> s
9
                       .eq(of("A"), (m -> of("AIRBUS")))
10
                       .eq(of("B"), (m -> of("BOEING")))
11
                       .eq(of("C"), (m -> of("CANADAIR")))
12
                       .eq(of("E"), (m -> of("EMBRAER")))
13
                       .eq(of("M"), (m -> of("MCDONNELL DOUGLAS")))
14
                       .defaults(m -> of("UNKNOWN"))
15
               )),
16
       excludeId()
17
));

1
aircraftCollection.aggregate(
2
   Arrays.asList(
3
           matchStage,
4
           groupStage,
5
           projectStage
6
   )
7
).forEach(doc -> System.out.println(doc.toJson()));

1
{"airline": "United", "model": "B757", "count": 7, "manufacturer": "BOEING"}
2
{"airline": "United", "model": "B777", "count": 5, "manufacturer": "BOEING"}
3
{"airline": "United", "model": "A320", "count": 21, "manufacturer": "AIRBUS"}
4
{"airline": "United", "model": "B737", "count": 45, "manufacturer": "BOEING"}