Google Firestore - Efficiently fetch a single document, perform a point query within a subcollection-CodePudding

Assume I am designing a new Firestore database. Assume I like the idea of a hierarchical design and, as a contrived example, each Year has a sequence of child Weeks of which each has Days.

What's the most performance efficient way to retrieve a single document for today? i.e. 2021-W51-Thursday

Answers are permitted to include changes to the model, e.g. "denormalizing" the day model such that it includes year, week and dayName fields (and querying them).

Otherwise a simple document reference may be the fastest way, like:

DocumentReference ref = db
    .Collection("years").Document("2021")
    .Collection("weeks").Document("51")
    .Collection("days").Document("Thursday");

Thanks.

CodePudding user response：

Any query that identifies a single document to fetch is equally performant to any other query that does the same at the scale that Firestore operates. The organization of collections or documents does not matter at al at scale. You might see some fluctuations in performance at small scale, depending on your data set, but that's not how Firestore is optimized to work.

All collections and all subcollections each have at least one index on the ID of the document that works the same way, independent of each other collection and index. If you can identify a unique document using its path:

/db/XXXX/weeks/YY/days/ZZZZ

Then it scales the same as a document stored using a more flat structure:

/db/XXXXYYZZZZ

It makes no difference at scale, since indexes on collections scale to an infinite number of documents with no theoretical upside limit. That's the magic of Firestore: if the system allows the query, then it will always perform well. You don't worry about scaling and performance at all. The indexes are automatically sharded across computing resources to optimize performance (vs. cost).

All of the above is true for fields of a document (instead of a document ID). You can think of a document ID as a field of a document that must be unique within a collection. Each field has its own index by default, and it scales massively.

With NoSQL databases like Firestore, you should structure your data in such a way that eases your queries, as long as those queries can be supported by indexes that operate at scale. This stands in contrast with SQL databases, which are optimized for query flexibility rather than massive scalability.