#mongo find

To avoid the hellish look of queries with infinitely nested DBObjects and strings as operands, the MongoDB Java driver provides an helper class called QueryBuilder which allows to specify the more commonly used search criteria with a simpler API. Here's the same program from the previous post, modified to build the query nicely:

https://gist.github.com/nofatclips/5638337

Surely, finding all the documents in a collection is not the most useful thing to do with a database. To specify a search criterion in your query, just pass a DBObject to the find() and count() methods:

https://gist.github.com/nofatclips/5638242

While the findOne() method returns a DBObject directly, calling the find() method requires a little more work: we need to handle a DBCursor:

https://gist.github.com/nofatclips/5638057

The call to close() is wrapped in the finally block, so that the remote cursor created on the server get closed no matter what happens in the try block.

Let's say that the DB has a collection of products, and each document (each product) has a set (array) of user reviews with user name, text body and star rating attributes. If you want to find all products with at least one review rating them 5 stars, this will NOT work:

db.products.find({reviews: {vote: 5}})

Mongo will actually try an exact match, so this will actually look for products with at least one review having no user name, no text body and a rating of 5 stars!

If (as it is very likely) this is not what intended, then dot notation is the way to go:

db.products.find({reviews.vote: 5})

The inequality operators can also be used on string values: lexicographical order (based on UTF-8 code) applies:

db.friends.find({"name": {"$gte": "D", "$lt": "G"}})

The binding between field and value is strictly typed: the query will only find items whose fields match the value and the type of the query. For example, if I have a friend called 3.14, the query:

db.friends.find({"name": {"$gte": "D"}})

When querying a collection, we're not always interested in matching on precise values. Enter inequality operators.

For example, we may want to extract numbers greater than 10 from a collection. The $gt operator allows this:

db.funnynumbers.find({"value": {"$gt": 10}})

If we want the number lower than or equal to 20, then the $lte operator is what we need:

db.funnynumbers.find({"value": {"$lte": 20}})

It's obviously possible to specift both conditions and get the numbers x: 10<x<=20

db.funnynumbers.find({"value": {"$gt": 10, "$lte": 20}})