Read Data from MongoDB With Queries

Deployment Type:
Client:

    Author: MongoDB Documentation Team

    In the first Read Data from MongoDB guide, you retrieved a document from the inventory collection. In this guide, you will:

    • use the insertMany command to insert more documents into the collection
    • query the documents

    Time required: 30 minutes

    What You’ll Need

    Warning

    If you are running MongoDB locally and have not enabled authentication, your MongoDB instance is not secure.

    Check Your Environment

    You will need to ensure that your MongoDB instance is running and accessible.

    Check that you have an Atlas account and have deployed a MongoDB database cluster. See Get Started with Atlas for information on how to login and create a cluster in Atlas.

    To make sure that your MongoDB instance is running on Windows, run the following command from the Windows command prompt:

    copy 
    tasklist /FI "IMAGENAME eq mongod.exe"

    If a mongod.exe instance is running, you will see something like:

    copy 
    Image Name                     PID Session Name        Session#    Mem Usage
========================= ======== ================ =========== ============
mongod.exe                    8716 Console                    1      9,508 K

    To make sure your MongoDB instance is running on Mac, run the following command from your terminal:

    copy 
    ps -e | grep 'mongod'

    If a mongod instance is running, you will see something like:

    copy 
    89780 ttys026    0:53.48 ./mongod

    To make sure your MongoDB instance is running on Linux, run the following command from your terminal:

    copy 
    ps -e| grep 'mongod'

    If a mongod instance is running, you will see something like:

    copy 
    89780 ttys026    0:53.48 ./mongod

    Procedure

    Import Data and Query It

    In the first part of this guide, you will insert more documents and retrieve some of these documents from MongoDB using a simple query.

    1

    Connect to your MongoDB instance.

    • Other

    Select the operating system platform on which you are running the MongoDB client you have selected.

    Pass the URI to the mongo shell followed by the --password option. You will then be prompted for your password.

    copy 
    mongo.exe <URISTRING_SHELL_NOUSER>

    Pass the URI to the mongo shell followed by the --password option. You will then be prompted for your password.

    copy 
    mongo <URISTRING_SHELL_NOUSER>

    Pass the URI to the mongo shell followed by the --password option. You will then be prompted for your password.

    copy 
    mongo <URISTRING_SHELL_NOUSER>

    If you wish to manually configure your Compass connection, load Compass and select the New Connection link. You will see a form where you can enter connection information for MongoDB.

    Atlas users can copy a URI string from the Atlas console into Compass. MongoDB Compass can detect whether you have a MongoDB URI connection string in your system clipboard and auto- populate the connection dialog from the URI.

    See Set Up Atlas Connectivity for information on how to get the Atlas connection string URI into your copy buffer.

    If Compass was already running when you copied the URI string, click the NEW CONNECTION button.

    ../../_images/connect-to-host.png

    You will be prompted to populate the connection dialog. Click Yes.

    You should then populate the password field with the proper password for your MongoDB user in the connection form.

    Note

    Errors related to connecting through Compass will appear in red at the top of the Connect screen.

    It’s a good idea to put your connection code in a class so that it can be reused.

    copy 
    from pymongo import MongoClient

class Connect(object):
    @staticmethod    
    def get_connection():
        return MongoClient("<URISTRING>")

    If your connection_string starts with mongodb+srv, you need to install the dnspython module with

    copy 
    python -m pip install dnspython

    Now add code to call the class you just created.

    copy 
    from connect import Connect
from pymongo import MongoClient

connection = Connect.get_connection()

    For the MongoDB java driver 3.7 and beyond, use the MongoClients.create() method.

    copy 
        final String uriString = "<URISTRING>";
    MongoClient mongoClient = MongoClients.create(uriString);

    For legacy drivers (prior to 3.7), use:

    copy 
        final String uriString = "<URISTRING>";
    MongoClientURI uri = new MongoClientURI(uriString);
    MongoClient mongoClient = new MongoClient(uri);
    copy

    The MongoDB.Bson package is used in CRUD operations, so you’ll import it here.

    copy 
    using System;
using MongoDB.Bson;
using MongoDB.Driver;

namespace csharptest
{
    class Connect
    {
        static void Main(string[] args)
        {
           var client = new MongoClient("<URISTRING>");
        }
    }
}

    Replace your password and any parameters surrounded by $[] in the connection string in the code below.

    For now, you will use the context.TODO().

    Later you’ll configure the context specific to your requirements.

    copy 
    client, err := mongo.Connect(context.TODO(), "<URISTRING>");

if err != nil {
	log.Fatal(err)
}

    You won’t know if the connection has been successful until you use the connection. A ping is one way you can test the connection. This is a full example of a Go connection to mongoDB, including a test ping.

    copy 
    package main

import (
	"context"
	"fmt"
	"github.com/mongodb/mongo-go-driver/mongo"
	"log"
)

func main() {
	// Open Connection
	client, err := mongo.Connect(context.TODO(), "<URISTRING>");

	if err != nil {
		log.Fatal(err)
	}

	// End Open Connection Code

	// Check the connection
	err = client.Ping(context.TODO(), nil)

	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Connected to MongoDB!")

}

    In your Go workspace and project folder, run build.

    copy 
    go build

    Now run the binary. For binaries that are not installed, you’ll have to specify the path.

    copy 
    go <path-to-yourproject>

    If you’d like to run the resulting binary without specifying a path, install the binary you just built into your Go workspace.

    copy 
    go install

    Now run the code. “yourprojectname” is the name of the project directory that contains the file with your main() function.

    For installed binaries use:

    copy 
    go yourprojectname

    For binaries that are not installed, you’ll have to specify the path.

    copy 
    go ./yourprojectname

    The default timeout for the Go driver to connect to the database is 30 seconds. In the event that you are unable to connect, you will see an error that resembles this:

    copy 
    2019/01/09 10:01:50 server selection timeout
    2

    Switch to the test Database

    • Other

    To switch to the test database in the mongo shell, type

    copy 
    use test

    If the database has not been created already, click the Create Database button.

    Screeenshot after connecting with the "Create Database" button.

    Select the test database on the left side of the Compass interface. Compass will list all of the collections in the database below the database name.

    Screenshot of the MongoDB Compass UI showing with the "test" database selected in the list of databases in the cluster.

    To access the test database:

    copy 
    db = client.test

    Switch to the test database and access the inventory collection.

    copy 
    MongoDatabase mongoDB = mongoClient.getDatabase("test");
MongoCollection<Document> collection = mongoDB.getCollection("inventory");

    Within the connect block, set db to the test database.

    copy 
    const db = client.db("test");

    To access the test database:

    copy 
    db = client.test

    Switch to the test database and access the inventory collection.

    copy 
    var database = client.GetDatabase("test");
var collection = database.GetCollection<BsonDocument>("inventory");

    To access the test database:

    copy 
    db := client.Database("test")
    3

    Load more data into MongoDB.

    Tip

    If you have already imported data into your database using mongoimport, you can skip this step.

    Before you can write queries to extract data in a meaningful way, you’ll need to add more data to your database. You can do that by running the insertMany() nethod:

    • Other
    copy 
    db.inventory.insertMany( [
   { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
   { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
   { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
   { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
   { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]);
    copy 
    [
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]

    For instructions on inserting documents in MongoDB Compass, see Insert Documents.

    copy 
    # Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON

db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
            "status": "A",
        },
    ]
)

    First you will need to create the MongoCollection object you would like to query against.

    copy 
    MongoCollection<Document> collection = db.getCollection("inventory");

    Now add the insertMany call.

    copy 
    collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));
    copy 
    db.collection('inventory').insertMany([
  { item: "journal",
    qty: 25,
    size: { h: 14, w: 21, uom: "cm" },
    status: "A"},
  { item: "notebook",
    qty: 50,
    size: { h: 8.5, w: 11, uom: "in" },
    status: "A"},
  { item: "paper",
    qty: 100,
    size: { h: 8.5, w: 11, uom: "in" },
    status: "D"},
  { item: "planner",
    qty: 75, size: { h: 22.85, w: 30, uom: "cm" },
    status: "D"},
  { item: "postcard",
    qty: 45,
    size: { h: 10, w: 15.25, uom: "cm" },
    status: "A"}
])
.then(function(result) {
  // process result
})
    copy 
    # Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON

await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
            "status": "A",
        },
    ]
)

    For completeness, this is how you might wrap this call and run it with the asyncio event loop.

    copy 
    async def do_insert_many():
    # Subdocument key order matters in a few of these examples so we have
    # to use bson.son.SON instead of a Python dict.
    from bson.son import SON
    await db.inventory.insert_many([
        {"item": "journal",
         "qty": 25,
         "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
         "status": "A"},
        {"item": "notebook",
         "qty": 50,
         "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
         "status": "A"},
        {"item": "paper",
         "qty": 100,
         "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
         "status": "D"},
        {"item": "planner",
         "qty": 75,
         "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
         "status": "D"},
        {"item": "postcard",
         "qty": 45,
         "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
         "status": "A"}])

loop = asyncio.get_event_loop()
loop.run_until_complete(do_insert_many())

    First you will need to initialize the collection.

    copy 
    var collection = database.GetCollection<BsonDocument>("inventory");

    Next create the array of BsonDocuments and pass it to the insertMany call on collection.

    copy 
    var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "status", "A" } },
};
collection.InsertMany(documents);
    copy 
    docs := []interface{}{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}

result, err := coll.InsertMany(context.Background(), docs)
    4

    Retrieve specific documents in a collection.

    You can retrieve specific documents from a collection by applying filter criteria.

    To specify filter criteria, pass a JSON document containing the criteria you are searching for to the find method.

    The following example illustrate using a status of “D” as criteria for narrowing a find on a collection.

    • Other
    copy 
    myCursor = db.inventory.find( { status: "D" } )

    Copy the following filter into the Compass query bar and click Find:

    copy 
    { status: "D" }
    copy 
    cursor = db.inventory.find({"status": "D"})
    copy 
    findIterable = collection.find(eq("status", "D"));
    copy 
    var cursor = db.collection('inventory').find({ status: "D" });
    copy 
    cursor = db.inventory.find({"status": "D"})

    For completeness, this is how you might wrap this call and run it with the asyncio event loop.

    copy 
    async def do_retrieve_status():
    cursor = db.inventory.find({"status": "D"})
    async for doc in cursor:
        åpprint.pprint(doc)

loop = asyncio.get_event_loop()
loop.run_until_complete(do_retrieve_status())
    copy 
    var filter = Builders<BsonDocument>.Filter.Eq("status", "D");
var result = collection.Find(filter).ToList();
    copy 
    cursor, err := coll.Find(
	context.Background(),
	bson.D{{"status", "D"}},
)
    5

    Iterate over the results.

    • Other

    By default, the shell will only show the first 20 documents and return a cursor. This is adequate when the result set only contains a few documents.

    If your result set is larger, to see all of the results of your query, iterate the cursor.

    copy 
    while (myCursor.hasNext()) {
    print(tojson(myCursor.next()));
}

    Note

    You can also manually iterate through the results by typing it when prompted by the shell.

    You will see a list of all of the documents that match your criteria in the query window.

    copy 
    from pprint import pprint

for inventory in cursor:
     pprint(inventory)

    You can implement a java.util.function.Consumer to print the results of the iteration

    copy 
    Consumer<Document> printConsumer = new Consumer<>() {
    public void accept(final Document doc) {
        System.out.println(doc.toJson());
    }
};

    Then iterate the cursor for documents, passing the printConsumer as a parameter.

    copy 
    findIterable.forEach(printConsumer);
    copy 
    function iterateFunc(doc) {
   console.log(JSON.stringify(doc, null, 4));
}

function errorFunc(error) {
   console.log(error);
}

cursor.forEach(iterateFunc, errorFunc);

    In the code snippet above you may have noticed the code that iterates the results and prints them to the command line:

    copy 
    async for doc in cursor:
    print(doc)
    copy 
    foreach (var doc in result) {
   Console.WriteLine(doc.ToJson());
}

    Iterate the results and print them to the command line:

    copy 
    for cursor.Next(context.TODO()) {
    elem := &bson.D{}
    if err := cursor.Decode(elem); err != nil {
            log.Fatal(err)
    }
    // ideally, you would do something with elem....
    // but for now just print it to the console
    fmt.Println(elem)
}
    6

    Check your results.

    If you have loaded data into your test database, you will see one or more JSON documents returned. Note that all records return have a status of “D”.

    Note

    Your ObjectId() values will differ from those shown.

    • Other
    copy 
    {
 item: "paper",
 qty: 100,
 size: {
   h: 8.5,
   w: 11,
   uom: "in"
   },
 status: "D"
},
{
 item: "planner",
 qty: 75,
 size: {
   h: 22.85,
   w: 30,
   uom: "cm"
   },
 status: "D"
}
    ../../_images/compass-find-filter-inventory.png
    copy 
    {u'_id': ObjectId('5ada8c109b267e9d1ade903a'),
 u'item': u'paper',
 u'qty': 100,
 u'size': {u'h': 8.5, u'uom': u'in', u'w': 11},
 u'status': u'D'}
{u'_id': ObjectId('5ada8c109b267e9d1ade903b'),
 u'item': u'planner',
 u'qty': 75,
 u'size': {u'h': 22.85, u'uom': u'cm', u'w': 30},
 u'status': u'D'}
    copy 
    { "_id" : { "$oid" : "5ada88359b267e9b5bd393bb" }, "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "D" }
{ "_id" : { "$oid" : "5ada88359b267e9b5bd393bc" }, "item" : "planner", "qty" : 75, "size" : { "h" : 22.85, "w" : 30, "uom" : "cm" }, "status" : "D" }
    copy 
    { _id: 5ade424c84c9ca2d56d31699,
  item: 'paper',
  qty: 100,
  size: { h: 8.5, w: 11, uom: 'in' },
  status: 'D' }
{ _id: 5ade424c84c9ca2d56d3169a,
  item: 'planner',
  qty: 75,
  size: { h: 22.85, w: 30, uom: 'cm' },
  status: 'D' }
    copy 
    {'_id': ObjectId('5adb5140aea650d18e402f19'),
 'item': 'paper',
 'qty': 100,
 'size': {'h': 8.5, 'uom': 'in', 'w': 11},
 'status': 'D'}
{'_id': ObjectId('5adb5140aea650d18e402f1a'),
 'item': 'planner',
 'qty': 75,
 'size': {'h': 22.85, 'uom': 'cm', 'w': 30},
 'status': 'D'}
    copy 
    { "_id" : ObjectId("5ade239b5923f61e2db8541e"), "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "D" }
{ "_id" : ObjectId("5ade239b5923f61e2db8541f"), "item" : "planner", "qty" : 75, "size" : { "h" : 22.850000000000001, "w" : 30, "uom" : "cm" }, "status" : "D" }
    copy 
    &[{_id ObjectID("5c3cf48cb05a4e6e614ce60c")} {item paper} {qty 100} {size [{h 8.5} {w 11} {uom in}]} {status D}]

&[{_id ObjectID("5c3cf48cb05a4e6e614ce60d")} {item planner} {qty 75} {size [{h 22.85} {w 30} {uom cm}]} {status D}]

    Query Data Using Embedded Documents as Criteria

    Now that you have an understanding of how to retrieve data using query documents, you will now query against embedded documents.

    1

    Retrieve specific documents in a collection based on the contents of an embedded document.

    If you wish to select documents that match all of the fields in an embedded JSON object, specify an exact match of the embedded document, including all of the fields and values in that embedded document in the order in which they appear in the collection.

    For example, the following query selects all documents where the size field equals the document { "h" : 14, "w" : 21, "uom" : "cm"}:

    • Other
    copy 
    myCursor = db.inventory.find( { size: { h: 14, w: 21, uom: "cm" } } )

    Copy the following filter into the Compass query bar and click Find:

    copy 
    { size: { h: 14, w: 21, uom: "cm" } }
    copy 
    cursor = db.inventory.find({"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})

    First you will need to create the MongoCollection object you would like to query against.

    copy 
    MongoCollection<Document> collection = db.getCollection("inventory");

    Now add the query.

    copy 
    FindIterable<Document> findIterable = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));
    copy 
    var cursor = db.collection('inventory').find({ 
  size: { h: 14, w: 21, uom: "cm" }
});
    copy 
    cursor = db.inventory.find({"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})

    For completeness, this is how you might wrap this call and run it with the asyncio event loop.

    copy 
    async def do_retrieve_embedded():
    cursor = db.inventory.find(
    {"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})
    async for doc in cursor:
        pprint.pprint(doc)

loop = asyncio.get_event_loop()
loop.run_until_complete(do_retrieve_embedded())
    copy 
    var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();
    copy 
    cursor, err := coll.Find(
	context.Background(),
	bson.D{
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
	})
    2

    Iterate over the results.

    • Other

    This query does not require cursor iteration in mongo shell because the shell returns up to 20 results.

    You will see a list of all of the documents that match your criteria in the query window.

    copy 
    from pprint import pprint

for inventory in cursor:
     pprint(inventory)

    You can implement a com.mongodb.Block to print the results of the iteration

    copy 
    Block<Document> printBlock = new Block<Document>() {
    @Override
    public void apply(final Document document) {
        System.out.println(document.toJson());
    }
};

    Then iterate the cursor for documents, passing the printBlock as a parameter.

    copy 
    findIterable.forEach(printBlock);
    copy 
    function iterateFunc(doc) {
   console.log(JSON.stringify(doc, null, 4));
}

function errorFunc(error) {
   console.log(error);
}

cursor.forEach(iterateFunc, errorFunc);

    In the code snippet above you may have noticed the code that iterates the results and prints them to the command line:

    copy 
    async for doc in cursor:
    print(doc)
    copy 
    foreach (var doc in result) {
   Console.WriteLine(doc.ToJson());
}
    copy 
    for cursor.Next(context.TODO()) {
    elem := &bson.D{}
    if err := cursor.Decode(elem); err != nil {
            log.Fatal(err)
    }
    // ideally, you would do something with elem....
    // but for now just print it to the console
    fmt.Println(elem)
}
    3

    Check your results.

    If you have loaded data into your test database, you will see one or more JSON documents returned. Note that the record matches the selection criteria exactly.

    Note

    Your ObjectId() values will differ from those shown.

    • Other
    copy 
    { "_id" : ObjectId("5ae14d2e124da839884ff939"), "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "cm" }, "status" : "A" }
    ../../_images/compass-match-embedded.png
    copy 
    {u'_id': ObjectId('5ada625baea65088bf0aa131'),
 u'item': u'journal',
 u'qty': 25,
 u'size': {u'h': 14, u'uom': u'cm', u'w': 21},
 u'status': u'A'}
    copy 
    { "_id" : { "$oid" : "5ada88359b267e9b5bd393b9" }, "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "cm" }, "status" : "A" }
    copy 
    { _id: 5ade424c84c9ca2d56d31697,
  item: 'journal',
  qty: 25,
  size: { h: 14, w: 21, uom: 'cm' },
  status: 'A' }
    copy 
    {'_id': ObjectId('5adb5140aea650d18e402f17'),
 'item': 'journal',
 'qty': 25,
 'size': {'h': 14, 'uom': 'cm', 'w': 21},
 'status': 'A'}
    copy 
    { "_id" : ObjectId("5ade248f6847901ef531c3ff"), "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "cm" }, "status" : "A" }å
    copy 
    &[{_id ObjectID("5c3cf740723ebcfd6eefa7ef")} {item journal} {qty 25} {size [{h 14} {w 21} {uom cm}]} {status A}]

    Query Data Using Embedded Documents With Dot Notation

    Now you will explore how to query embedded documents using dot notation.

    1

    Retrieve specific documents in a collection with dot notation.

    If you wish to select documents that exactly match just one of the fields in an embedded JSON object, use dot notation. ("field.nestedField").

    When querying using dot notation., the field and nested field names must be inside quotation marks.

    The following example selects all documents where the field uom nested in the size field equals "in":

    • Other
    copy 
    myCursor = db.inventory.find( { "size.uom": "in" } )

    Copy the following filter into the Compass query bar and click Find:

    copy 
    { "size.uom": "in" }
    copy 
    cursor = db.inventory.find({"size.uom": "in"})

    First you will need to create the MongoCollection object you would like to query against.

    copy 
    MongoCollection<Document> collection = db.getCollection("inventory");

    Now add the query.

    copy 
    findIterable = collection.find(eq("size.uom", "in"));
    copy 
    var cursor = db.collection('inventory').find({ 
  "size.uom": "in"
});
    copy 
    cursor = db.inventory.find({"size.uom": "in"})

    For completeness, this is how you might wrap this call and run it with the asyncio event loop.

    copy 
    async def do_retrieve_embedded_dot():
    cursor = db.inventory.find({"size.uom": "in"})
    async for doc in cursor:
        pprint.pprint(doc)


loop = asyncio.get_event_loop()
loop.run_until_complete(do_retrieve_embedded_dot())
    copy 
    var filter = Builders<BsonDocument>.Filter.Eq("size.uom", "in");
var result = collection.Find(filter).ToList();
    copy 
    cursor, err := coll.Find(
	context.Background(),
	bson.D{{"size.uom", "in"}},
)
    2

    Iterate over the results.

    • Other

    By default, the shell will only show the first 20 documents and return a cursor. This is adequate when the result set only contains a few documents.

    If your result set is larger, to see all of the results of your query, iterate the cursor.

    copy 
    while (myCursor.hasNext()) {
    print(tojson(myCursor.next()));
}

    Note

    You can also manually iterate through the results by typing it when prompted by the shell.

    You will see a list of all of the documents that match your criteria in the query window.

    copy 
    from pprint import pprint

for inventory in cursor:
     pprint(inventory)

    You can implement a java.util.function.Consumer to print the results of the iteration

    copy 
    Consumer<Document> printConsumer = new Consumer<>() {
    public void accept(final Document doc) {
        System.out.println(doc.toJson());
    }
};

    Then iterate the cursor for documents, passing the printConsumer as a parameter.

    copy 
    findIterable.forEach(printConsumer);
    copy 
    function iterateFunc(doc) {
   console.log(JSON.stringify(doc, null, 4));
}

function errorFunc(error) {
   console.log(error);
}

cursor.forEach(iterateFunc, errorFunc);

    In the code snippet above you may have noticed the code that iterates the results and prints them to the command line:

    copy 
    async for doc in cursor:
    print(doc)
    copy 
    foreach (var doc in result) {
   Console.WriteLine(doc.ToJson());
}

    Iterate the results and print them to the command line:

    copy 
    for cursor.Next(context.TODO()) {
    elem := &bson.D{}
    if err := cursor.Decode(elem); err != nil {
            log.Fatal(err)
    }
    // ideally, you would do something with elem....
    // but for now just print it to the console
    fmt.Println(elem)
}
    3

    Check your results.

    If you have loaded data into your test database, you will see one or more JSON documents returned. Note that the result record has a uom of in.

    Note

    Your ObjectId() values will differ from those shown.

    • Other
    copy 
    { "_id" : ObjectId("5ae14d2e124da839884ff93a"), "item" : "notebook", "qty" : 50, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "A" }
{ "_id" : ObjectId("5ae14d2e124da839884ff93b"), "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "D" }
    ../../_images/compass-find-nested-field.png
    copy 
    {u'_id': ObjectId('5ada625baea65088bf0aa132'),
 u'item': u'notebook',
 u'qty': 50,
 u'size': {u'h': 8.5, u'uom': u'in', u'w': 11},
 u'status': u'A'}
{u'_id': ObjectId('5ada625baea65088bf0aa133'),
 u'item': u'paper',
 u'qty': 100,
 u'size': {u'h': 8.5, u'uom': u'in', u'w': 11},
 u'status': u'D'}

    Create a method to print the results of the iteration

    copy 
    { "_id" : { "$oid" : "5ada88359b267e9b5bd393ba" }, "item" : "notebook", "qty" : 50, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "A" }
{ "_id" : { "$oid" : "5ada88359b267e9b5bd393bb" }, "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "D" }
    copy 
    { _id: 5ade424c84c9ca2d56d31698,
  item: 'notebook',
  qty: 50,
  size: { h: 8.5, w: 11, uom: 'in' },
  status: 'A' }
{ _id: 5ade424c84c9ca2d56d31699,
  item: 'paper',
  qty: 100,
  size: { h: 8.5, w: 11, uom: 'in' },
  status: 'D' }
    copy 
    {'_id': ObjectId('5adb5140aea650d18e402f18'),
 'item': 'notebook',
 'qty': 50,
 'size': {'h': 8.5, 'uom': 'in', 'w': 11},
 'status': 'A'}
{'_id': ObjectId('5adb5140aea650d18e402f19'),
 'item': 'paper',
 'qty': 100,
 'size': {'h': 8.5, 'uom': 'in', 'w': 11},
 'status': 'D'}
    copy 
    { "_id" : ObjectId("5ade2538321fd31f43ea1f56"), "item" : "notebook", "qty" : 50, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "A" }
{ "_id" : ObjectId("5ade2538321fd31f43ea1f57"), "item" : "paper", "qty" : 100, "size" : { "h" : 8.5, "w" : 11, "uom" : "in" }, "status" : "D" }
    copy 
    &[{_id ObjectID("5c3cfb2b62883946fc77553b")} {item notebook} {qty 50} {size [{h 8.5} {w 11} {uom in}]} {status A}]
&[{_id ObjectID("5c3cfb2b62883946fc77553c")} {item paper} {qty 100} {size [{h 8.5} {w 11} {uom in}]} {status D}]

    When you are done working with your MongoDB data, close your connection to MongoDB:

    copy 
    mongoClient.close();

    Summary

    If you have successfully completed this guide, you have retrieved data from MongoDB using specific criteria as expressed in MongoDB’s query syntax. You have also used the embedded document query syntax to retrieve documents based on embedded fields.

    What’s Next

    In the next guide, you’ll learn how to read data from MongoDB using operators and compound queries.

    © MongoDB, Inc 2008-present. MongoDB, Mongo, and the leaf logo are registered trademarks of MongoDB, Inc.