Our Mflix application allows us to do a lot of different things including listing, for example, the movies of our catalog. Now, this means that we perform a couple of queries to the database. For example, we have the query that allows us to click on a particular movie and go to its detail page, which is great. The query that allows us to do that is the get_movie here that basically sets a query that looks for its _id based on some _id that we know and we pass along and get back the movie details. That's all great and fine, but there's other functionality like, for example, if we want to find all the Titanic movies, you can search and it finds it for us. So all the movies that have the word Titanic somewhere either in the title but also not that much like Titan and Clash of Titans. Why is this related with Titanic? How does MongoDB know about that? To answer that and other questions, we can use indexes. In particular in this lesson, we are going to look into indexes present in the movies collection. But before we go and jump directly into the different index types that MongoDB supports, it is important for you to realize that indexes are special data structures used by databases including MongoDB that allows us to do some enhanced functionality like, for example, making our queries more efficient and faster. In MongoDB in particular, we have other functionality that is also supported by indexes like, for example, the geospatial capabilities and the text indexes. Now, to help us out uncover the indexes in movies, we have, as part of this lesson and part of the material for this lesson, the indexes on movies, Jupyter notebook. Now, as usual, what we need to do is basically initialize by importing the necessary modules, connect to our Atlas accounts, and provide in the URI. As you can see here, we are able to connect, no errors, and we have a database object. Fantastic. But what we are interested on knowing is, what type of indexes do we have? Now, this method here, movies.index_information provides us back with a list of the existing indexes for this collection. In this example here, we have four _id_ which is the primary key index of our collection. And then, we have three other indexes. These are secondary indexes, indexes that the user, in our case, in our application Mflix, created to support its queries. So let's have a look into detail in a couple of them. Now, the nomenclature used by MongoDB to name the indexes is as follows. We're going to have the index fields, then we're going to have _id and a value, either 1 or -1, telling us if the field itself is sort of ascending or descending. And if it's an index that spans over more than one field, like in this case, tomatoes.viewer.numReviews, is a embedded field, and it's sorted descending, where the sign -1 will tell us just that. And then, you have these keys that are exactly that translation. The key genres 1 and tomatoes.viewer.numReviews, -1. All indexes in MongoDB follow that nomenclature, but you can set, at creation time, a different name. In this case, we've been lazy and let's MongoDB do it's magic. Now, something very interesting about MongoDB is, regardless if it is a root-level field like genres, or even a very nested embedded field like tomatoes.viewer.numReviews, we can create different types of indexes that span across those different fields, no matter where they are placed inside of the document. In this particular case, this is a compound index. Compound index stands for an index that spans across different fields inside your documents. So the combination of those two values on these fields will generate an index, a data structure that will map those two together, so we can fastly access all queries that inside of genres and numReviews on tomatoes. Now, although indexes are very cool, and they are used to enhance our reads and making sure that we have the combinations needed to, for example, do efficient sorts, it is important to raise to your attention that the fact that we have indexes, or the more indexes we have, the slower our rides on the collection that supports those indexes will become. There's also a max number of indexes which is 64 per collection in MongoDB, so be careful about the number of indexes because they will have
