How to access the John Hopkins University Covid-19 Data

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package com.mongodb.coronavirus;

import com.mongodb.ConnectionString;
import com.mongodb.MongoClientSettings;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;
import org.bson.conversions.Bson;

import java.util.Date;

import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Sorts.descending;
import static org.bson.codecs.configuration.CodecRegistries.fromProviders;
import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;

public class MongoDB {

    public static void main(String[] args) {
        try (MongoClient client = MongoClients.create(getMongoClient())) {
            int earthRadius = 6371;
            MongoDatabase db = client.getDatabase("covid19");
            MongoCollection<Stat> statsCollection = db.getCollection("statistics", Stat.class);
            MongoCollection<Metadata> metadataCollection = db.getCollection("metadata", Metadata.class);

            System.out.println("Query to get the last 5 entries for France (continent only)");
            Bson franceFilter = eq("country", "France");
            Bson noStateFilter = eq("state", null);
            statsCollection.find(and(franceFilter, noStateFilter)).sort(descending("date")).limit(5).forEach(System.out::println);

            System.out.println("\nQuery to get the last day data (limited to 5 docs here).");
            Metadata metadata = metadataCollection.find().first();
            Date lastDate = metadata.getLastDate();
            Bson lastDayFilter = eq("date", lastDate);
            statsCollection.find(lastDayFilter).limit(5).forEach(System.out::println);

            System.out.println("\nQuery to get the last day data for all the countries within 500km of Paris.");
            Bson aroundParisFilter = geoWithinCenterSphere("loc", 2.341908, 48.860199, 500.0 / earthRadius);
            statsCollection.find(and(lastDayFilter, aroundParisFilter)).forEach(System.out::println);

            System.out.println("\nPrint the Metadata summary.");
            metadataCollection.find().forEach(System.out::println);
        }
    }

    private static MongoClientSettings getMongoClient() {
        String connectionString = "mongodb+srv://readonly:readonly@covid-19.hip2i.mongodb.net/test";
        CodecRegistry pojoCodecRegistry = fromProviders(PojoCodecProvider.builder().automatic(true).build());
        CodecRegistry codecRegistry = fromRegistries(MongoClientSettings.getDefaultCodecRegistry(), pojoCodecRegistry);
        return MongoClientSettings.builder()
                                  .applyConnectionString(new ConnectionString(connectionString))
                                  .codecRegistry(codecRegistry)
                                  .build();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
const MongoClient = require("mongodb").MongoClient;

const uri =
  "mongodb+srv://readonly:readonly@covid-19.hip2i.mongodb.net/test?retryWrites=true&w=majority";

const client = new MongoClient(uri, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

client.connect((err) => {
  const statistics = client.db("covid19").collection("statistics");

  // find the latest 15 cases from France
  statistics
    .find({ country: "France" })
    .sort([["a", 1]])
    .limit(15)
    .toArray(function (err, docs) {
      if (err) {
        console.error(err);
      }
      console.log(docs);
      client.close();
    });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#!python3

import pymongo
from pymongo import MongoClient
from tabulate import tabulate

EARTH_RADIUS = 6371.0
MDB_URL = "mongodb+srv://readonly:readonly@covid-19.hip2i.mongodb.net/test?retryWrites=true&w=majority"


def main():
    client = MongoClient(MDB_URL)
    db = client.get_database("covid19")
    stats = db.get_collection("statistics")
    metadata = db.get_collection("metadata")

    # Get some results for the UK:
    print("\nMost recent 10 statistics for the UK:")
    results = (
        stats.find({"country": "United Kingdom", "state": None})
        .sort("date", pymongo.DESCENDING)
        .limit(10)
    )
    print_table(["date", "confirmed", "deaths"], results)

    # Get the last date loaded:
    meta = metadata.find_one()
    last_date = meta["last_date"]

    # Show the 5 locations with the most recovered cases:
    print("\nThe last day's highest reported recoveries:")
    results = (
        stats.find({"date": last_date}).sort("recovered", pymongo.DESCENDING).limit(5)
    )
    print_table(["combined_name", "recovered"], results)

    # Confirmed cases for all countries within 500km of Paris:
    print(
        "\nThe last day's confirmed cases for all the countries within 500km of Paris:"
    )
    results = stats.find(
        {
            "date": last_date,
            "loc": {
                "$geoWithin": {
                    "$centerSphere": [[2.341908, 48.860199], 500.0 / EARTH_RADIUS]
                }
            },
        }
    )
    print_table(["combined_name", "confirmed"], results)


def print_table(doc_keys, search_results, headers=None):
    """
    Utility function to print a query result as a table.

    Params:
        doc_keys: A list of keys for data to be extracted from each document.
        search_results: A MongoDB cursor.
        headers: A list of headers for the table. If not provided, attempts to
            generate something sensible from the provided `doc_keys`
    """
    if headers is None:
        headers = [key.replace("_", " ").replace("-", " ").title() for key in doc_keys]
    records = (extract_tuple(doc, doc_keys) for doc in search_results)
    print(tabulate(records, headers=headers))


def extract_tuple(mapping, keys):
    """
    Extract a tuple from a mapping by requesting a sequence of keys.

    Missing keys will result in `None` values in the resulting tuple.
    """
    return tuple([mapping.get(key) for key in keys])


if __name__ == "__main__":
    main()