Read Data using Operators and Compound Queries

1
using MongoDB.Bson;
2
using MongoDB.Driver;
3

4
// Replace the uri string with your MongoDB deployment's connection string.
5
var uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
6

7
var client = new MongoClient(uri);
8

9
var coll = client.GetDatabase("sample_guides").GetCollection<BsonDocument>("planets");
10
// find code goes here
11
var cursor = from planet in coll.AsQueryable()
12
             where planet["surfaceTemperatureC.mean"] < 15
13
             select planet;
14

15
foreach (var document in cursor)
16
{
17
    Console.WriteLine(document);
18
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
7
	"go.mongodb.org/mongo-driver/bson"
8
	"go.mongodb.org/mongo-driver/mongo"
9
	"go.mongodb.org/mongo-driver/mongo/options"
10
)
11
12
func main() {
13
	uri := "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"
14
15
	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
16
	if err != nil {
17
		panic(err)
18
	}
19
20
	defer func() {
21
		if err = client.Disconnect(context.TODO()); err != nil {
22
			panic(err)
23
		}
24
	}()
25
	coll := client.Database("sample_guides").Collection("planets")
26
27
	// find code goes here
28
	filter := bson.D{{"surfaceTemperatureC.mean", bson.D{{"$lt", 15}}}}
29
	cursor, err := coll.Find(context.TODO(), filter)
30
	if err != nil {
31
		panic(err)
32
	}
33
34
	for cursor.Next(context.TODO()) {
35
		var result bson.M
36
		if err := cursor.Decode(&result); err != nil {
37
			panic(err)
38
		}
39
		fmt.Println(result)
40
	}
41
	if err := cursor.Err(); err != nil {
42
		panic(err)
43
	}
44
}

1
import com.mongodb.client.*;
2
import com.mongodb.client.model.Filters.*;
3
import org.bson.Document;
4
import org.bson.conversions.Bson;
5
6
public class CrudRead {
7
    public static void main(String[] args) {
8
        String uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
9
10
        try (MongoClient mongoClient = MongoClients.create(uri)) {
11
            MongoCollection<Document> coll = mongoClient.getDatabase("sample_guides")
12
                    .getCollection("planets");
13
14
            // find code goes here
15
            Bson filter = lt("surfaceTemperatureC.mean", 15);
16
            MongoCursor<Document> cursor = coll.find(filter).iterator();
17
18
            // iterate code goes here
19
            try {
20
                while (cursor.hasNext()) {
21
                    System.out.println(cursor.next().toJson());
22
                }
23
            } finally {
24
                cursor.close();
25
            }
26
        }
27
    }
28
}

1
const { MongoClient } = require("mongodb");
2
// Replace the uri string with your MongoDB deployment's connection string.
3
const uri =
4
  "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority";
5
const client = new MongoClient(uri);
6
async function run() {
7
  try {
8
    await client.connect();
9
    const coll = client.db("sample_guides").collection("planets");
10
11
    // find code goes here
12
    const cursor = coll.find({ "surfaceTemperatureC.mean": { $lt: 15 } });
13
14
    await cursor.forEach(console.log);
15
  } finally {
16
    // Ensures that the client will close when you finish/error
17
    await client.close();
18
  }
19
}
20
run().catch(console.dir);

1
from pymongo import MongoClient
2
3
# Replace the uri string with your MongoDB deployment's connection string.
4
uri = "mongodb+srv://<user>:<password>@<cluster-url>?retryWrites=true&writeConcern=majority"
5
6
client = MongoClient(uri)
7
coll = client.sample_guides.planets
8
9
# find code goes here
10
cursor = coll.find({"surfaceTemperatureC.mean": {"$lt": 15}})
11
12
for doc in cursor:
13
    print(doc)
14
15
# Close the connection to MongoDB when you're done.
16
client.close()

1
// find code goes here
2
var cursor = from planet in coll.AsQueryable()
3
             where planet["surfaceTemperatureC.mean"] < 15 && planet["surfaceTemperatureC.min"] > -100
4
             select planet;
5

1
// find code goes here
2
filter := bson.D{
3
	{"$and",
4
		bson.A{
5
			bson.D{{"surfaceTemperatureC.mean",
6
				bson.D{{"$lt", 15}},
7
			}},
8
			bson.D{{"surfaceTemperatureC.min",
9
				bson.D{{"$gt", -100}},
10
			}},
11
		},
12
	},
13
}
14
cursor, err := coll.Find(context.TODO(), filter)
15
if err != nil {
16
	panic(err)
17
}

1
// find code goes here
2
Bson filter = and(lt("surfaceTemperatureC.mean", 15), gt("surfaceTemperatureC.min", -100));
3
MongoCursor<Document> cursor = coll.find(filter).iterator();

1
// find code goes here
2
const cursor = coll.find({
3
  "surfaceTemperatureC.mean": { $lt: 15 },
4
  "surfaceTemperatureC.min": { $gt: -100 },
5
});

1
# find code goes here
2
cursor = coll.find(
3
    {"surfaceTemperatureC.mean": {"$lt": 15}, "surfaceTemperatureC.min": {"$gt": -100}}
4
)

1
// find code goes here
2
var cursor = from planet in coll.AsQueryable()
3
             where planet["orderFromSun"] > 7 || planet["orderFromSun"] < 2
4
             select planet;

1
// find code goes here
2
filter := bson.D{
3
	{"$or",
4
		bson.A{
5
			bson.D{{"orderFromSun",
6
				bson.D{{"$gt", 7}},
7
			}},
8
			bson.D{{"orderFromSun", bson.D{{"$lt", 2}}}},
9
		},
10
	},
11
}
12
13
cursor, err := coll.Find(context.TODO(), filter)
14
if err != nil {
15
	panic(err)
16
}

1
// find code goes here
2
Bson filter = or(gt("orderFromSun", 7), lt("orderFromSun", 2));
3
MongoCursor<Document> cursor = coll.find(filter).iterator();

1
// find code goes here
2
const cursor = coll.find({
3
  $or: [{ orderFromSun: { $gt: 7 } }, { orderFromSun: { $lt: 2 } }],
4
});

1
# find code goes here
2
cursor = coll.find(
3
    {
4
        "$or": [
5
            {"orderFromSun": {"$gt": 7}},
6
            {"orderFromSun": {"$lt": 2}},
7
        ]
8
    }
9
)