MongoDB CRUD I

The .find() method is used to select documents in a collection and return a cursor to the selected documents.

The following example will print all documents from a collection named posts:

db.posts.find()

When using the .find() method, a query can be passed in as a parameter to search for specific documents.

For example, consider a collection named guitarists. To retrieve a specific document, query criteria can be passed in:

db.guitarists.find({ last_name: "Santana" })

Note: If no document matches the filtering criteria, then no documents will be printed.

The comparison operators $gt and $gte can be used to match documents where the value for a particular field is greater than, or greater than or equal to a specified value, respectively.

For example, consider a collection named inventory where you’re trying to retrieve documents with a field named quantity with a value greater than or equal to 20. This can be accomplished with the following command:

db.inventory.find( { quantity: { $gte: 20 } } )

The .sort() method can be appended to queries to order matching documents according to one or more fields. To specify sorting orders, a value of 1 and -1 are used. 1 is used for ascending order while -1 is used for descending order.

For example, consider a collection named documentaries. If we wanted to view a list of documents sorted in descending order by the field release_year, we would use the following command:

db.documentaries.find().sort({ release_year: -1 })

When using the .find() method, we can limit the amount of data returned by including a projection document to specify or restrict fields to return.

For example, consider a collection named restaurants. Assuming each document includes several fields, if we want to view only the names and locations of restaurants that have a grade field, with the value of "A", we can run the following command:

db.restaurants.find( { grade: "A" }, { name: 1, location: 1 } )

If the field in the projection has the value of 1, it will be included in the returned documents.

When running the .find() method, we can limit the amount of data returned by including a projection document to specify or restrict fields to return.

Consider a collection named inventory. Assuming each document includes several fields, if we want to view all the fields of the documents and only exclude the field origin and original_cost, we can run the following command:

db.restaurants.find( {}, { origin: 0, original_cost: 0 } )

An embedded document can be accessed by using the .find() method and using dot notation in our query filter to access the embedded field.

For example, consider a collection named employees with documents in the following format:

{
  firstName: "John",
  lastName: "King",
  department: { name: "Finance" },
  address: {
    phone: { type: "Home", number: "111-000-000" }
  }
}

To retrieve documents from the collection from the "Finance" department, we can run the following command:

db.employees.find({ "department.name": "Finance" }

The comparison operators $lt and $lte can be used to match documents where the value for a particular field is less than, or less than or equal to the specified value, respectively.

For example, consider a collection named inventory where we want to retrieve documents with a field named quantity with a value less than or equal to 20. This can be accomplished with the following command:

db.inventory.find( { quantity: { $lte: 20 } } )

The .find() method can query a collection for an array containing specific values by passing in a query argument that includes the field and array to match:

Check out the following example of a .find() operation on a collection named interviewees:

db.interviewees.find({
  languages: ["C#", "Javascript", "Ruby"]
})

The .find() method can query collections on a single array element by providing a query document containing the field name and the specific element we want to match as its value.

Check out the following example searching for a document containing "Best Picture" as a value in a field named "awards":

db.academyawards.find({
  awards: ["Best Picture"]
})

The .$all operator selects the documents where the value of a field is an array that contains all the specified elements, in any order, without regard to additional elements in the array.

The query below will match documents that contain at least those specified values, in any order, in the field awards.

db.academyawards.find({ 
  awards: { $all: [ "Best Picture", "Best Director", "Best Director" ] } 
})

The .find() method can query a collection with comparison operators to match documents where the array contains one or more elements that satisfy the query conditions in some combination.

The following query will find a document in a ufc_contestants collections where the array field championship_years is greater than 2004 but less than 2008:

db.ufc_contestants.find({
  championship_years: { $gt: 2004, $lt: 2008 }
})

The .find() method can use the $elemMatch operator to find documents with at least one array field. The finding operation matches the data in the array field with the criteria mentioned with $elemMatch.

The following query looks for documents in which the array field bands contains values where active is true, and the formation_year is greater than 1990:

db.music_fest.find({
  bands: { $elemMatch: { active: true, formation_year: { $gte: 1990} } } 
})

We can use .find() to query an array with embedded documents for an exact match by providing a query argument containing the specific fields and their associated values. The query will only match documents with the specific order we provide in our query.

Consider the following document as an example:

{
  _id: ObjectId(...),
  name: "Miyu Kato",
  country: "Japan",
  wimbledon_doubles_placements: 
  [{ 
    year: 2016,
    place: 2
  }, 
  { 
    year: 2017,
    place: 1
  }]
}

We can query the embedded documents inside of the wimbledon_doubles_placements array field:

db.tennis_players.find( { "wimbledon_doubles_placements": { year: 2016, place: 2 } } )

We can use .find() to query an array with embedded documents for a single field by providing a query argument for the specific field using dot (.) notation.

The following query will query the array field wimbledon_doubles_placements for a embedded document with the field year with the value of 2016:

db.tennis_players.find( { "wimbledon_doubles_placements.year": 2016 )